added unsafe member functions to directly manipulate the queue and mutex

Author: dk949

include/mt_queue/include/ut/mt_queue/mt_queue.hpp

@@ -197,6 +197,51 @@ class MtQueue {
         std::lock_guard<std::mutex> g {m_mu};
         return fn(m_q);
     }
+
+    /**
+     * Returns mutable reference to the internal mutex
+     *
+     * This function should almost never be used! Using the mutex directly can lead to deadlocks.
+     * 
+     * !!!!!!!!WARNING!!!!!!!!
+     * Locking the mutex, then calling any non-`unsafe` member function in the same thread *WILL* lead to a deadlock!
+     *
+     * To perform multiple operations atomically on the underlying queue, prefer `underLock`
+     */
+    [[nodiscard]]
+    std::mutex &unsafeGetMutex() const {
+        return m_mu;
+    }
+
+    /**
+     * Returns a reference to the internal queue.
+     *
+     * This function should almost never be used! Accessing the queue directly can lead to data-races.
+     *
+     * In order to safely access the underlying queue in a multithreaded environment, first lock the mutex,
+     * returned from `unsafeGetMutex`, or use one of the non-`unsafe` functions instead of directly
+     * manipulating the queue.
+     */
+    [[nodiscard]]
+    Q &unsafeGetQueue() {
+        return m_q;
+    }
+
+    /**
+     * Returns a reference to the internal queue.
+     *
+     * This function should almost never be used! Accessing the queue directly can lead to data-races.
+     *
+     * In order to safely access the underlying queue in a multithreaded environment, first lock the mutex,
+     * returned from `unsafeGetMutex`, or use one of the non-`unsafe` functions instead of directly
+     * manipulating the queue.
+     */
+    [[nodiscard]]
+    Q const &unsafeGetQueue() const {
+        return m_q;
+    }
+
+
 private:
     mutable std::mutex m_mu;
     mutable std::condition_variable m_cv;

tests/mt_queue.cpp

@@ -1,9 +1,11 @@
 //  NOLINTBEGIN(readability-magic-numbers,google-build-using-namespace)
+#include <catch2/catch_test_macros.hpp>
 #include <ut/mt_queue/mt_queue.hpp>
 #include <ut/overload/overload.hpp>
 
 #include <barrier>
 #include <chrono>
+#include <iostream>
 #include <numeric>
 #include <thread>
 #include <utility>
@@ -235,4 +237,35 @@ TEMPLATE_TEST_CASE("Single trheaded using shared_ptr",
     REQUIRE(*front == 30);
 }
 
+TEMPLATE_TEST_CASE("2 threaded get mutex", "[mt_queue]", std::queue<int>, std::deque<int>, std::priority_queue<int>) {
+
+    MtQueue<int, TestType> q;
+
+    std::barrier b {2};
+    auto t1 = std::jthread([&q, &b]() {
+        b.arrive_and_wait();
+        auto &mu = q.unsafeGetMutex();
+        mu.lock();
+        std::this_thread::sleep_for(100ms);
+        ut::Overload {
+            [](std::queue<int> &inner_q) { inner_q.push(10); },
+            [](std::deque<int> &inner_q) { inner_q.push_back(10); },
+            [](std::priority_queue<int> &inner_q) { inner_q.push(10); },
+        }(q.unsafeGetQueue());
+        mu.unlock();
+    });
+    auto t2 = std::jthread([&q, &b]() {
+        b.arrive_and_wait();
+        std::this_thread::sleep_for(50ms);
+        q.push(9);
+    });
+
+    t1.join();
+    t2.join();
+    REQUIRE(q.front() == 10);
+    REQUIRE(q.pop() == 10);
+    REQUIRE(q.front() == 9);
+    REQUIRE(q.pop() == 9);
+}
+
 //  NOLINTEND(readability-magic-numbers,google-build-using-namespace)