ReadWriteMutex.h

#pragma once
 
#include <mutex>
#include <atomic>
#include <thread>
#include <iostream>
#include <condition_variable>
 
namespace mvlt
{
    class ReadWriteMutex
    {
    private:
        std::mutex WriteMutex, ReadMutex;
        std::atomic_int ReadCounter;
        std::atomic_bool IsCondVarWaiting;
        std::condition_variable Cv;
 
        // A variable for switching the operation of the mutex. It is needed so that you can disable the mutex during inheritance
        bool IsActive = true;
 
    public:
        ReadWriteMutex() noexcept;
 
        void Disable() noexcept;
 
        void ReadLock() noexcept;
 
        void ReadUnlock() noexcept;
 
        void WriteLock() noexcept;
 
        void WriteUnlock() noexcept;
    };
 
    class RecursiveReadWriteMutex
    {
    private:
        ReadWriteMutex Rwmx;
 
        // A variable for switching the operation of the mutex. It is needed so that you can disable the mutex during inheritance
        bool IsActive = true;
 
    public:
        void Disable() noexcept;
 
        void ReadLock() noexcept;
 
        void ReadUnlock() noexcept;
 
        void WriteLock() noexcept;
 
        void WriteUnlock() noexcept;
    };
 
    template <class Mutex>
    class ReadLock
    {
    private:
        Mutex* Mtx = nullptr;
 
    public:
        ReadLock() noexcept = delete;
 
        ReadLock(const ReadLock<Mutex>& other) noexcept = delete;
 
        ReadLock(ReadLock<Mutex>&& other) noexcept = delete;
 
        explicit ReadLock(Mutex& mtx) noexcept : Mtx(&mtx)
        {
            Mtx->ReadLock();
        }
 
        ReadLock<Mutex>& operator=(const ReadLock<Mutex>& other) noexcept = delete;
 
        ReadLock<Mutex>& operator=(ReadLock<Mutex>&& other) noexcept = delete;
 
        ~ReadLock() noexcept
        {
            Mtx->ReadUnlock();
        }
    };
 
    template <class Mutex>
    class WriteLock
    {
    private:
        Mutex* Mtx = nullptr;
 
    public:
        WriteLock() noexcept = delete;
 
        WriteLock(const WriteLock<Mutex>& other) noexcept = delete;
 
        WriteLock(WriteLock<Mutex>&& other) noexcept = delete;
 
        explicit WriteLock(Mutex& mtx) noexcept : Mtx(&mtx)
        {
            Mtx->WriteLock();
        }
 
        WriteLock<Mutex>& operator=(const WriteLock<Mutex>& other) noexcept = delete;
 
        WriteLock<Mutex>& operator=(WriteLock<Mutex>&& other) noexcept = delete;
 
        ~WriteLock() noexcept
        {
            Mtx->WriteUnlock();
        }
    };
}