Add mutex encapsulation

Author: hcbcomeup

include/cppbase/mutex-inl.hpp

@@ -0,0 +1,62 @@
+#pragma once
+
+#ifndef CPPBASE_MUTEX_INL_HPP
+#define CPPBASE_MUTEX_INL_HPP
+
+#include "mutex.hpp"
+
+namespace cppbase {
+
+template<typename Mtx>
+void Mutex<Mtx>::lock()
+{
+    mutex_.lock();
+}
+
+template<typename Mtx>
+bool Mutex<Mtx>::try_lock() noexcept
+{
+    return mutex_.try_lock();
+}
+
+template<typename Mtx>
+void Mutex<Mtx>::unlock() noexcept
+{
+    mutex_.unlock();
+}
+
+template<typename Mtx>
+template <class Rep, class Period>
+auto Mutex<Mtx>::try_lock_for(const std::chrono::duration<Rep, Period>& rel_time)
+    -> decltype(std::declval<Mtx>().try_lock_for(rel_time), bool())
+{
+    static_assert(
+        std::is_same_v<Mtx, std::timed_mutex> ||
+        std::is_same_v<Mtx, std::recursive_timed_mutex>,
+        "Mutex<try_lock_for>: Mtx must be std::timed_mutex or std::recursive_timed_mutex!"
+    );
+    return mutex_.try_lock_for(rel_time);
+}
+
+template<typename Mtx>
+template <class Clock, class Duration>
+auto Mutex<Mtx>::try_lock_until(const std::chrono::time_point<Clock, Duration>& abs_time)
+    -> decltype(std::declval<Mtx>().try_lock_until(abs_time), bool())
+{
+    static_assert(
+        std::is_same_v<Mtx, std::timed_mutex> ||
+        std::is_same_v<Mtx, std::recursive_timed_mutex>,
+        "Mutex<try_lock_until>: Mtx must be std::timed_mutex or std::recursive_timed_mutex!"
+    );
+    return mutex_.try_lock_until(abs_time);
+}
+
+template<typename Mtx>
+typename Mtx::native_handle_type Mutex<Mtx>::native_handle() noexcept
+{
+    return mutex_.native_handle();
+}
+
+} // namespace cppbase
+
+#endif // CPPBASE_MUTEX_INL_HPP

include/cppbase/mutex.hpp

@@ -0,0 +1,67 @@
+#pragma once
+#ifndef CPPBASE_MUTEX_HPP
+#define CPPBASE_MUTEX_HPP
+
+#include <mutex>
+#include <chrono>
+#include <type_traits>
+#include "nocopyable.hpp"
+#include "nomoveable.hpp"
+
+namespace cppbase {
+
+/**
+ * @brief Generic template mutex class, based on standard mutex type encapsulation
+ * @tparam Mtx Underlying mutex type, default is std::mutex
+ * @note Template implementation is in mutex-inl.hpp, must be included after declaration
+ */
+template<typename Mtx = std::mutex>
+class Mutex final: public NoCopyable, public NoMoveable
+{
+public:
+    void lock();
+    bool try_lock() noexcept;
+    void unlock() noexcept;
+
+    template <class Rep, class Period>
+    auto try_lock_for(const std::chrono::duration<Rep, Period>& rel_time) 
+        -> decltype(std::declval<Mtx>().try_lock_for(rel_time), bool());
+    
+    template <class Clock, class Duration>
+    auto try_lock_until(const std::chrono::time_point<Clock, Duration>& abs_time)
+        -> decltype(std::declval<Mtx>().try_lock_until(abs_time), bool());
+
+    typename Mtx::native_handle_type native_handle() noexcept;
+    
+private:
+    Mtx mutex_;
+};
+
+/**
+ * @brief RAII wrapper for Mutex, auto lock/unlock
+ * @tparam Mtx Underlying mutex type (same as Mutex's template parameter)
+ * @note Only works with cppbase::Mutex, not std::mutex directly
+ */
+template<typename Mtx = std::mutex>
+class LockGuard final: public NoCopyable, public NoMoveable
+{
+public:
+    explicit LockGuard(Mutex<Mtx> &mtx) noexcept 
+        : mutex_(mtx)
+    {
+        mutex_.lock();
+    }
+
+    ~LockGuard() noexcept
+    {
+        mutex_.unlock();
+    }
+
+private:
+    Mutex<Mtx> &mutex_;
+};
+
+} // namespace cppbase
+
+#include "mutex-inl.hpp"
+#endif // CPPBASE_MUTEX_HPP

include/cppbase/nocopyable.hpp

@@ -1,3 +1,4 @@
+#pragma once
 #ifndef CPPBASE_NONCOPYABLE_HPP
 #define CPPBASE_NONCOPYABLE_HPP
 

include/cppbase/nomoveable.hpp

@@ -1,3 +1,4 @@
+#pragma once
 #ifndef CPPBASE_NONMOVABLE_HPP
 #define CPPBASE_NONMOVABLE_HPP