@op-engineering/op-sqlite 11.2.14 → 11.3.0

package/cpp/ThreadPool.cpp

@@ -3,116 +3,118 @@
 namespace opsqlite {
 
 ThreadPool::ThreadPool() : done(false) {
-  // This returns the number of threads supported by the system. If the
-  // function can't figure out this information, it returns 0. 0 is not good,
-  // so we create at least 1
-//  auto numberOfThreads = std::thread::hardware_concurrency();
-//  if (numberOfThreads == 0) {
-//    numberOfThreads = 1;
-//  }
-
-  auto numberOfThreads = 1;
-  for (unsigned i = 0; i < numberOfThreads; ++i) {
-    // The threads will execute the private member `doWork`. Note that we need
-    // to pass a reference to the function (namespaced with the class name) as
-    // the first argument, and the current object as second argument
-    threads.emplace_back(&ThreadPool::doWork, this);
-  }
+    // This returns the number of threads supported by the system. If the
+    // function can't figure out this information, it returns 0. 0 is not good,
+    // so we create at least 1
+    //  auto numberOfThreads = std::thread::hardware_concurrency();
+    //  if (numberOfThreads == 0) {
+    //    numberOfThreads = 1;
+    //  }
+
+    auto numberOfThreads = 1;
+    for (unsigned i = 0; i < numberOfThreads; ++i) {
+        // The threads will execute the private member `doWork`. Note that we
+        // need to pass a reference to the function (namespaced with the class
+        // name) as the first argument, and the current object as second
+        // argument
+        threads.emplace_back(&ThreadPool::doWork, this);
+    }
 }
 
 // The destructor joins all the threads so the program can exit gracefully.
 // This will be executed if there is any exception (e.g. creating the threads)
 ThreadPool::~ThreadPool() {
-  // So threads know it's time to shut down
-  done = true;
+    // So threads know it's time to shut down
+    done = true;
 
-  // Wake up all the threads, so they can finish and be joined
-  workQueueConditionVariable.notify_all();
+    // Wake up all the threads, so they can finish and be joined
+    workQueueConditionVariable.notify_all();
 
-  for (auto &thread : threads) {
-    if (thread.joinable()) {
-      thread.join();
+    for (auto &thread : threads) {
+        if (thread.joinable()) {
+            thread.join();
+        }
     }
-  }
 
-  threads.clear();
+    threads.clear();
 }
 
 // This function will be called by the server every time there is a request
 // that needs to be processed by the thread pool
-void ThreadPool::queueWork(const std::function<void(void)>& task) {
-  // Grab the mutex
-  std::lock_guard<std::mutex> g(workQueueMutex);
+void ThreadPool::queueWork(const std::function<void(void)> &task) {
+    // Grab the mutex
+    std::lock_guard<std::mutex> g(workQueueMutex);
 
-  // Push the request to the queue
-  workQueue.push(task);
+    // Push the request to the queue
+    workQueue.push(task);
 
-  // Notify one thread that there are requests to process
-  workQueueConditionVariable.notify_one();
+    // Notify one thread that there are requests to process
+    workQueueConditionVariable.notify_one();
 }
 
 // Function used by the threads to grab work from the queue
 void ThreadPool::doWork() {
-  // Loop while the queue is not destructing
-  while (!done) {
-    std::function<void(void)> task;
-
-    // Create a scope, so we don't lock the queue for longer than necessary
-    {
-      std::unique_lock<std::mutex> g(workQueueMutex);
-      workQueueConditionVariable.wait(g, [&] {
-        // Only wake up if there are elements in the queue or the program is
-        // shutting down
-        return !workQueue.empty() || done;
-      });
-
-      // If we are shutting down exit without trying to process more work
-      if (done) {
-        break;
-      }
-
-      task = workQueue.front();
-      workQueue.pop();
+    // Loop while the queue is not destructing
+    while (!done) {
+        std::function<void(void)> task;
+
+        // Create a scope, so we don't lock the queue for longer than necessary
+        {
+            std::unique_lock<std::mutex> g(workQueueMutex);
+            workQueueConditionVariable.wait(g, [&] {
+                // Only wake up if there are elements in the queue or the
+                // program is shutting down
+                return !workQueue.empty() || done;
+            });
+
+            // If we are shutting down exit without trying to process more work
+            if (done) {
+                break;
+            }
+
+            task = workQueue.front();
+            workQueue.pop();
+        }
+        ++busy;
+        task();
+        --busy;
     }
-    ++busy;
-    task();
-    --busy;
-  }
 }
 
 void ThreadPool::waitFinished() {
-  std::unique_lock<std::mutex> g(workQueueMutex);
-  workQueueConditionVariable.wait(
-      g, [&] { return workQueue.empty() && (busy == 0); });
+    std::unique_lock<std::mutex> g(workQueueMutex);
+    workQueueConditionVariable.wait(
+        g, [&] { return workQueue.empty() && (busy == 0); });
 }
 
 void ThreadPool::restartPool() {
-  // So threads know it's time to shut down
-  done = true;
+    // So threads know it's time to shut down
+    done = true;
 
-  // Wake up all the threads, so they can finish and be joined
-  workQueueConditionVariable.notify_all();
+    // Wake up all the threads, so they can finish and be joined
+    workQueueConditionVariable.notify_all();
 
-  for (auto &thread : threads) {
-    if (thread.joinable()) {
-      thread.join();
+    for (auto &thread : threads) {
+        if (thread.joinable()) {
+            thread.join();
+        }
     }
-  }
 
-  threads.clear();
+    threads.clear();
 
-  auto numberOfThreads = std::thread::hardware_concurrency();
-  if (numberOfThreads == 0) {
-    numberOfThreads = 1;
-  }
+    auto numberOfThreads = std::thread::hardware_concurrency();
+    if (numberOfThreads == 0) {
+        numberOfThreads = 1;
+    }
 
-  for (unsigned i = 0; i < numberOfThreads; ++i) {
-    // The threads will execute the private member `doWork`. Note that we need
-    // to pass a reference to the function (namespaced with the class name) as
-    // the first argument, and the current object as second argument
-    threads.emplace_back(&ThreadPool::doWork, this);
-  }
+    for (unsigned i = 0; i < numberOfThreads; ++i) {
+        // The threads will execute the private member `doWork`. Note that we
+        // need to pass a reference to the function (namespaced with the class
+        // name) as the first argument, and the current object as second
+        // argument
+        threads.emplace_back(&ThreadPool::doWork, this);
+    }
 
-  done = false;
+    done = false;
 }
 } // namespace opsqlite

package/cpp/ThreadPool.h

@@ -11,34 +11,34 @@
 namespace opsqlite {
 
 class ThreadPool {
-public:
-  ThreadPool();
-  ~ThreadPool();
-  void queueWork(const std::function<void(void)>& task);
-  void waitFinished();
-  void restartPool();
-
-private:
-  unsigned int busy{};
-  // This condition variable is used for the threads to wait until there is work
-  // to do
-  std::condition_variable_any workQueueConditionVariable;
-
-  // We store the threads in a vector, so we can later stop them gracefully
-  std::vector<std::thread> threads;
-
-  // Mutex to protect workQueue
-  std::mutex workQueueMutex;
-
-  // Queue of requests waiting to be processed
-  std::queue<std::function<void(void)>> workQueue;
-
-  // This will be set to true when the thread pool is shutting down. This tells
-  // the threads to stop looping and finish
-  bool done;
-
-  // Function used by the threads to grab work from the queue
-  void doWork();
+  public:
+    ThreadPool();
+    ~ThreadPool();
+    void queueWork(const std::function<void(void)> &task);
+    void waitFinished();
+    void restartPool();
+
+  private:
+    unsigned int busy{};
+    // This condition variable is used for the threads to wait until there is
+    // work to do
+    std::condition_variable_any workQueueConditionVariable;
+
+    // We store the threads in a vector, so we can later stop them gracefully
+    std::vector<std::thread> threads;
+
+    // Mutex to protect workQueue
+    std::mutex workQueueMutex;
+
+    // Queue of requests waiting to be processed
+    std::queue<std::function<void(void)>> workQueue;
+
+    // This will be set to true when the thread pool is shutting down. This
+    // tells the threads to stop looping and finish
+    bool done;
+
+    // Function used by the threads to grab work from the queue
+    void doWork();
 };
 
 } // namespace opsqlite

package/cpp/bindings.cpp

@@ -27,143 +27,147 @@ std::vector<std::shared_ptr<DBHostObject>> dbs;
 // React native will try to clean the module on JS context invalidation
 // (CodePush/Hot Reload) The clearState function is called
 void invalidate() {
-  for (const auto &db : dbs) {
-    db->invalidate();
-  }
+    for (const auto &db : dbs) {
+        db->invalidate();
+    }
 
-  // Clear our existing vector of shared pointers so they can be garbage
-  // collected
-  dbs.clear();
+    // Clear our existing vector of shared pointers so they can be garbage
+    // collected
+    dbs.clear();
 }
 
 void install(jsi::Runtime &rt,
              const std::shared_ptr<react::CallInvoker> &invoker,
              const char *base_path, const char *crsqlite_path,
              const char *sqlite_vec_path) {
-  _base_path = std::string(base_path);
-  _crsqlite_path = std::string(crsqlite_path);
-  _sqlite_vec_path = std::string(sqlite_vec_path);
-
-  auto open = HOST_STATIC_FN("open") {
-    jsi::Object options = args[0].asObject(rt);
-    std::string name = options.getProperty(rt, "name").asString(rt).utf8(rt);
-    std::string path = std::string(_base_path);
-    std::string location;
-    std::string encryption_key;
-
-    if (options.hasProperty(rt, "location")) {
-      location = options.getProperty(rt, "location").asString(rt).utf8(rt);
-    }
-
-    if (options.hasProperty(rt, "encryptionKey")) {
-      encryption_key =
-          options.getProperty(rt, "encryptionKey").asString(rt).utf8(rt);
-    }
+    _base_path = std::string(base_path);
+    _crsqlite_path = std::string(crsqlite_path);
+    _sqlite_vec_path = std::string(sqlite_vec_path);
+
+    auto open = HOST_STATIC_FN("open") {
+        jsi::Object options = args[0].asObject(rt);
+        std::string name =
+            options.getProperty(rt, "name").asString(rt).utf8(rt);
+        std::string path = std::string(_base_path);
+        std::string location;
+        std::string encryption_key;
+
+        if (options.hasProperty(rt, "location")) {
+            location =
+                options.getProperty(rt, "location").asString(rt).utf8(rt);
+        }
+
+        if (options.hasProperty(rt, "encryptionKey")) {
+            encryption_key =
+                options.getProperty(rt, "encryptionKey").asString(rt).utf8(rt);
+        }
 
 #ifdef OP_SQLITE_USE_SQLCIPHER
-    if (encryption_key.empty()) {
-      log_to_console(rt, "Encryption key is missing for SQLCipher");
-    }
+        if (encryption_key.empty()) {
+            log_to_console(rt, "Encryption key is missing for SQLCipher");
+        }
 #endif
 
-    if (!location.empty()) {
-      if (location == ":memory:") {
-        path = ":memory:";
-      } else if (location.rfind('/', 0) == 0) {
-        path = location;
-      } else {
-        path = path + "/" + location;
-      }
-    }
-
-    std::shared_ptr<DBHostObject> db = std::make_shared<DBHostObject>(
-        rt, path, invoker, name, path, _crsqlite_path, _sqlite_vec_path,
-        encryption_key);
-    dbs.emplace_back(db);
-    return jsi::Object::createFromHostObject(rt, db);
-  });
-
-  auto is_sqlcipher = HOST_STATIC_FN("isSQLCipher") {
+        if (!location.empty()) {
+            if (location == ":memory:") {
+                path = ":memory:";
+            } else if (location.rfind('/', 0) == 0) {
+                path = location;
+            } else {
+                path = path + "/" + location;
+            }
+        }
+
+        std::shared_ptr<DBHostObject> db = std::make_shared<DBHostObject>(
+            rt, path, invoker, name, path, _crsqlite_path, _sqlite_vec_path,
+            encryption_key);
+        dbs.emplace_back(db);
+        return jsi::Object::createFromHostObject(rt, db);
+    });
+
+    auto is_sqlcipher = HOST_STATIC_FN("isSQLCipher") {
 #ifdef OP_SQLITE_USE_SQLCIPHER
-    return true;
+        return true;
 #else
-    return false;
+        return false;
 #endif
-  });
+    });
 
-  auto is_ios_embedded = HOST_STATIC_FN("isIOSEmbedded") {
+    auto is_ios_embedded = HOST_STATIC_FN("isIOSEmbedded") {
 #ifdef OP_SQLITE_USE_PHONE_VERSION
-    return true;
+        return true;
 #else
-    return false;
+        return false;
 #endif
-  });
+    });
 
-  auto is_libsql = HOST_STATIC_FN("isLibsql") {
+    auto is_libsql = HOST_STATIC_FN("isLibsql") {
 #ifdef OP_SQLITE_USE_LIBSQL
-    return true;
+        return true;
 #else
-    return false;
+        return false;
 #endif
-  });
+    });
 
 #ifdef OP_SQLITE_USE_LIBSQL
-  auto open_remote = HOST_STATIC_FN("openRemote") {
-    jsi::Object options = args[0].asObject(rt);
-    std::string url = options.getProperty(rt, "url").asString(rt).utf8(rt);
-    std::string auth_token =
-        options.getProperty(rt, "authToken").asString(rt).utf8(rt);
-
-    std::shared_ptr<DBHostObject> db =
-        std::make_shared<DBHostObject>(rt, url, auth_token, invoker);
-    return jsi::Object::createFromHostObject(rt, db);
-  });
-
-  auto open_sync = HOST_STATIC_FN("openSync") {
-    jsi::Object options = args[0].asObject(rt);
-    std::string name = options.getProperty(rt, "name").asString(rt).utf8(rt);
-    std::string path = std::string(_base_path);
-    std::string url = options.getProperty(rt, "url").asString(rt).utf8(rt);
-    std::string auth_token =
-        options.getProperty(rt, "authToken").asString(rt).utf8(rt);
-    int sync_interval = 0;
-    if (options.hasProperty(rt, "syncInterval")) {
-      sync_interval =
-          static_cast<int>(options.getProperty(rt, "syncInterval").asNumber());
-    }
-    std::string location;
-
-    if (options.hasProperty(rt, "location")) {
-      location = options.getProperty(rt, "location").asString(rt).utf8(rt);
-    }
-
-    if (!location.empty()) {
-      if (location == ":memory:") {
-        path = ":memory:";
-      } else if (location.rfind("/", 0) == 0) {
-        path = location;
-      } else {
-        path = path + "/" + location;
-      }
-    }
-
-    std::shared_ptr<DBHostObject> db = std::make_shared<DBHostObject>(
-        rt, invoker, name, path, url, auth_token, sync_interval);
-    return jsi::Object::createFromHostObject(rt, db);
-  });
+    auto open_remote = HOST_STATIC_FN("openRemote") {
+        jsi::Object options = args[0].asObject(rt);
+        std::string url = options.getProperty(rt, "url").asString(rt).utf8(rt);
+        std::string auth_token =
+            options.getProperty(rt, "authToken").asString(rt).utf8(rt);
+
+        std::shared_ptr<DBHostObject> db =
+            std::make_shared<DBHostObject>(rt, url, auth_token, invoker);
+        return jsi::Object::createFromHostObject(rt, db);
+    });
+
+    auto open_sync = HOST_STATIC_FN("openSync") {
+        jsi::Object options = args[0].asObject(rt);
+        std::string name =
+            options.getProperty(rt, "name").asString(rt).utf8(rt);
+        std::string path = std::string(_base_path);
+        std::string url = options.getProperty(rt, "url").asString(rt).utf8(rt);
+        std::string auth_token =
+            options.getProperty(rt, "authToken").asString(rt).utf8(rt);
+        int sync_interval = 0;
+        if (options.hasProperty(rt, "syncInterval")) {
+            sync_interval = static_cast<int>(
+                options.getProperty(rt, "syncInterval").asNumber());
+        }
+        std::string location;
+
+        if (options.hasProperty(rt, "location")) {
+            location =
+                options.getProperty(rt, "location").asString(rt).utf8(rt);
+        }
+
+        if (!location.empty()) {
+            if (location == ":memory:") {
+                path = ":memory:";
+            } else if (location.rfind("/", 0) == 0) {
+                path = location;
+            } else {
+                path = path + "/" + location;
+            }
+        }
+
+        std::shared_ptr<DBHostObject> db = std::make_shared<DBHostObject>(
+            rt, invoker, name, path, url, auth_token, sync_interval);
+        return jsi::Object::createFromHostObject(rt, db);
+    });
 #endif
 
-  jsi::Object module = jsi::Object(rt);
-  module.setProperty(rt, "open", std::move(open));
-  module.setProperty(rt, "isSQLCipher", std::move(is_sqlcipher));
-  module.setProperty(rt, "isLibsql", std::move(is_libsql));
-  module.setProperty(rt, "isIOSEmbedded", std::move(is_ios_embedded));
+    jsi::Object module = jsi::Object(rt);
+    module.setProperty(rt, "open", std::move(open));
+    module.setProperty(rt, "isSQLCipher", std::move(is_sqlcipher));
+    module.setProperty(rt, "isLibsql", std::move(is_libsql));
+    module.setProperty(rt, "isIOSEmbedded", std::move(is_ios_embedded));
 #ifdef OP_SQLITE_USE_LIBSQL
-  module.setProperty(rt, "openRemote", std::move(open_remote));
-  module.setProperty(rt, "openSync", std::move(open_sync));
+    module.setProperty(rt, "openRemote", std::move(open_remote));
+    module.setProperty(rt, "openSync", std::move(open_sync));
 #endif
 
-  rt.global().setProperty(rt, "__OPSQLiteProxy", std::move(module));
+    rt.global().setProperty(rt, "__OPSQLiteProxy", std::move(module));
 }
 
 } // namespace opsqlite