mt_queue: added underLock function

Author: dk949

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

@@ -1,6 +1,7 @@
 #ifndef UT_MT_QUEUE_HPP
 #define UT_MT_QUEUE_HPP
 
+#include <type_traits>
 #if __cplusplus < 202'002L
 #    error this file has to be compiled with at least C++20
 #endif
@@ -174,18 +175,40 @@ class MtQueue {
         std::lock_guard<std::mutex> g {m_mu};
         return m_q.empty();
     }
+
+    /**
+     * Access internal queue under a mutex lock.
+     *
+     * Allows performing multiple operations on a queue atomically
+     */
+    template<typename Fn>
+    auto underLock(Fn &&fn) {
+        std::lock_guard<std::mutex> g {m_mu};
+        return fn(m_q);
+    }
+
+    /**
+     * Access internal queue under a mutex lock.
+     *
+     * Allows performing multiple operations on a queue atomically
+     */
+    template<typename Fn>
+    auto underLock(Fn &&fn) const {
+        std::lock_guard<std::mutex> g {m_mu};
+        return fn(m_q);
+    }
 private:
     mutable std::mutex m_mu;
     mutable std::condition_variable m_cv;
     Q m_q;
     static constexpr bool has_top = requires {
-        { m_q.top() } -> std::same_as<T const &>;
+        {m_q.top()}->std::same_as<T const &>;
     };
     static constexpr bool has_front = requires {
-        { m_q.front() } -> std::same_as<T const &>;
+        {m_q.front()}->std::same_as<T const &>;
     }
     || requires {
-        { m_q.front() } -> std::same_as<T &>;
+        {m_q.front()}->std::same_as<T &>;
     };
     static constexpr bool has_push = requires(T t) {
         m_q.push(t);

tests/mt_queue.cpp

@@ -1,10 +1,12 @@
 //  NOLINTBEGIN(readability-magic-numbers,google-build-using-namespace)
 #include <ut/mt_queue/mt_queue.hpp>
+#include <ut/overload/overload.hpp>
 
 #include <barrier>
 #include <chrono>
 #include <numeric>
 #include <thread>
+#include <utility>
 namespace chr = std::chrono;
 using namespace std::chrono_literals;
 
@@ -69,6 +71,23 @@ TEMPLATE_TEST_CASE("Single threaded", "[mt_queue]", std::queue<int>, std::deque<
         REQUIRE(p.has_value());
         REQUIRE(*p == 7);
     }
+
+    SECTION("underLock") {
+        q.underLock([](auto &inner) {
+            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); },
+            }(inner);
+            auto back = ut::Overload {
+                [&](std::queue<int> &inner_q) { return inner_q.back(); },
+                [&](std::deque<int> &inner_q) { return inner_q.back(); },
+                [&](std::priority_queue<int> &inner_q) { return inner_q.top(); },
+            }(inner);
+            REQUIRE(back == 10);
+        });
+        std::as_const(q).underLock([](auto &inner) { REQUIRE(!inner.empty()); });
+    }
 }
 
 TEMPLATE_TEST_CASE("Multi-threaded", "[mt_queue]", std::queue<int>, std::deque<int>, std::priority_queue<int>) {