Add mutex

Author: flyingsilverfin

c/typedb_driver.i

@@ -118,13 +118,73 @@ struct TransactionCallbackDirector {
 #include <memory>
 #include <iostream>
 #include <unordered_map>
-// TODO: ADD MUTEX
-static std::unordered_map<size_t, TransactionCallbackDirector*> transactionOnCloseCallbacks {};
+
+class ThreadSafeTransactionCallbacks {
+private:
+    // 1. The static map to protect
+    static std::unordered_map<size_t, TransactionCallbackDirector*> s_transactionOnCloseCallbacks;
+
+    // 2. The static mutex to manage access
+    static std::mutex s_mutex;
+
+public:
+    // Delete copy/move constructors and assignment operators
+    // to prevent accidental copying of the singleton-like structure
+    ThreadSafeTransactionCallbacks(const ThreadSafeTransactionCallbacks&) = delete;
+    ThreadSafeTransactionCallbacks& operator=(const ThreadSafeTransactionCallbacks&) = delete;
+
+    // --- Core Operations ---
+
+    /**
+     * @brief Inserts a key-value pair into the map in a thread-safe manner.
+     */
+    static void insert(size_t key, TransactionCallbackDirector* value) {
+        // Lock the mutex for the duration of this scope
+        std::lock_guard<std::mutex> lock(s_mutex);
+
+        // Thread-safe insertion
+        s_transactionOnCloseCallbacks[key] = value;
+    }
+
+    /**
+     * @brief Retrieves a value associated with a key in a thread-safe manner.
+     * @returns The value pointer, or nullptr if the key is not found.
+     */
+    static TransactionCallbackDirector* find(size_t key) {
+        // Lock the mutex for the duration of this scope
+        std::lock_guard<std::mutex> lock(s_mutex);
+
+        // Thread-safe lookup
+        auto it = s_transactionOnCloseCallbacks.find(key);
+        if (it != s_transactionOnCloseCallbacks.end()) {
+            return it->second;
+        }
+        return nullptr; // Return nullptr if not found
+    }
+
+    /**
+     * @brief Removes a key-value pair from the map in a thread-safe manner.
+     */
+    static void remove(size_t key) {
+        // Lock the mutex for the duration of this scope
+        std::lock_guard<std::mutex> lock(s_mutex);
+
+        // Thread-safe removal
+        s_transactionOnCloseCallbacks.erase(key);
+    }
+
+    // Add other necessary map operations (e.g., size(), contains(), clear()) here...
+};
+
+// Initialize the static members
+std::unordered_map<size_t, TransactionCallbackDirector*> ThreadSafeTransactionCallbacks::s_transactionOnCloseCallbacks;
+std::mutex ThreadSafeTransactionCallbacks::s_mutex;
+
 static void transaction_callback_execute(size_t ID, Error* error) {
     try {
-        auto cb = transactionOnCloseCallbacks.at(ID);
+        auto cb = ThreadSafeTransactionCallbacks::find(ID);
         cb->callback(error);
-        transactionOnCloseCallbacks.erase(ID);
+        ThreadSafeTransactionCallbacks::remove(ID);
     } catch (std::exception const& e) {
         std::cerr << "[ERROR] " << e.what() << std::endl;
     }
@@ -138,7 +198,7 @@ static void transaction_callback_execute(size_t ID, Error* error) {
 void transaction_on_close_register(const Transaction* transaction, TransactionCallbackDirector* handler) {
     static std::atomic_size_t nextID;
     std::size_t ID = nextID.fetch_add(1);
-    transactionOnCloseCallbacks.insert({ID, handler});
+    ThreadSafeTransactionCallbacks::insert(ID, handler);
     transaction_on_close(transaction, ID, &transaction_callback_execute);
 }
 %}

rust/tests/integration/driver.rs

@@ -72,7 +72,7 @@ fn transaction_callback() {
             }
         }));
 
-        drop(transaction); // TODO: drop isn't blocking... so we need to spin?
+        drop(transaction); // TODO: drop isn't blocking... so we need to spin? or is there an alternative?
 
         while !close_called.load(Ordering::Acquire) {
             // Yield the current time slice to the OS scheduler.