SharedRecursiveMutex.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_THREAD_SHAREDRECURSIVEMUTEX_HPP_
#define ECSTASY_THREAD_SHAREDRECURSIVEMUTEX_HPP_
 
#include <atomic>
#include <thread>
#include <shared_mutex>
#include <unordered_map>
 
namespace ecstasy::thread
{
    class SharedRecursiveMutex {
      public:
        SharedRecursiveMutex() = default;
 
        ~SharedRecursiveMutex() = default;
 
        void lock();
 
        void lock_shared() const;
 
        void lock() const
        {
            lock_shared();
        }
 
        void unlock();
 
        void unlock_shared() const;
 
        void unlock() const
        {
            unlock_shared();
        }
 
        [[nodiscard]] constexpr const std::shared_mutex &get_shared_mutex(void) noexcept
        {
            return _shared_mutex;
        }
 
        [[nodiscard]] constexpr int get_lock_count(void) const noexcept
        {
            return _lock_count;
        }
 
        [[nodiscard]] int get_shared_lock_count(void) const noexcept;
 
        [[nodiscard]] constexpr const std::atomic<std::thread::id> &get_owner(void) const noexcept
        {
            return _owner;
        }
 
      private:
        [[nodiscard]] bool has_shared_lock(void) const noexcept;
 
        mutable std::shared_mutex _shared_mutex;
        std::atomic<std::thread::id> _owner;
        int _lock_count;
        mutable std::unordered_map<std::thread::id, int> _shared_locks;
    };
 
} // namespace ecstasy::thread
 
#endif // !ECSTASY_THREAD_SHAREDRECURSIVEMUTEX_HPP_