RWMutex.hpp

#pragma once

#include <atomic>
#include <condition_variable>
#include <mutex>

namespace samchon
{
namespace library
{
    class RWMutex
    {
    private:
        // Status variables
        size_t readers_count_;
        std::atomic<bool> writing_;

        // Conditional waiters
        std::condition_variable read_cv_;
        std::condition_variable write_cv_;

        // Lockers
        std::mutex readers_count_mtx_;
        std::mutex read_mtx_;
        std::mutex write_mtx_;

    public:
        RWMutex()
        {
            readers_count_ = 0;
            writing_ = false;
        };

        void readLock() const
        {
            // WAIT WRITE_UNLOCK
            std::unique_lock<std::mutex> uk((std::mutex&)read_mtx_);

            while (writing_ == true)
                ((std::condition_variable&)read_cv_).wait(uk);

            // PLUS NUMBER OF READERS
            ((std::mutex&)readers_count_mtx_).lock();
            ((size_t&)readers_count_)++;
            ((std::mutex&)readers_count_mtx_).unlock();
        };

        void readUnlock() const
        {
            std::unique_lock<std::mutex> uk((std::mutex&)readers_count_mtx_);

            //Â÷°¨ Àü ÀÌ¹Ì 0 (°úµµÇÑ readUnlock ¼öÇà) Àº ¾È µÊ            if (readers_count_ != 0 && --((size_t&)readers_count_) == 0)
            {
                uk.unlock();

                ((std::condition_variable&)read_cv_).notify_all();
                ((std::condition_variable&)write_cv_).notify_all();
            }
        };

        /**
         * @brief Lock on writing
         *
         * @details
         * <p> Changes writing flag to true. </p>
         *
         * <p> If another write_lock or read_lock is on a progress, wait until them to be unlocked. </p>
         *
         *  \li Writing can be done by only a section at once.
         *  \li Writing can't be done when reading.
         *
         * @note You've to call write_unlock when writing work was terminated.
         */
        void writeLock()
        {
            std::unique_lock<std::mutex> uk(write_mtx_);

            while (writing_ == true || readers_count_ > 0)
                write_cv_.wait(uk);

            writing_ = true;
        };

        /**
         * @brief Unlock on writing
         */
        void writeUnlock()
        {
            writing_ = false;
            
            read_cv_.notify_all();
            write_cv_.notify_all();
        };
    };
};
};

#include <samchon/library/UniqueReadLock.hpp>
#include <samchon/library/UniqueWriteLock.hpp>

#include <samchon/library/SharedReadLock.hpp>
#include <samchon/library/SharedWriteLock.hpp>
            if (readers_count_ != 0 && --((size_t&)readers_count_) == 0)
            {
                uk.unlock();

                ((std::condition_variable&)read_cv_).notify_all();
                ((std::condition_variable&)write_cv_).notify_all();
            }
        };

        void writeLock()
        {
            std::unique_lock<std::mutex> uk(write_mtx_);

            while (writing_ == true || readers_count_ > 0)
                write_cv_.wait(uk);

            writing_ = true;
        };

        void writeUnlock()
        {
            writing_ = false;
            
            read_cv_.notify_all();
            write_cv_.notify_all();
        };
    };
};
};

#include <samchon/library/UniqueReadLock.hpp>
#include <samchon/library/UniqueWriteLock.hpp>

#include <samchon/library/SharedReadLock.hpp>
#include <samchon/library/SharedWriteLock.hpp>