SharedReadLock.hpp

#pragma once

#include <atomic>
#include <samchon/library/RWMutex.hpp>

namespace samchon
{
namespace library
{
    class SharedReadLock
    {
    private:
        const RWMutex *rw_mutex;

        std::atomic<size_t> *reference;

        std::atomic<bool> *locked;

    public:
        /* -----------------------------------------------------------
            CONSTRUCTORS
        ----------------------------------------------------------- */
        SharedReadLock(const RWMutex &rw_mutex, bool lock = true)
        {
            this->rw_mutex = &rw_mutex;
            this->reference = new std::atomic<size_t>(0);
            this->locked = new std::atomic<bool>(false);

            if (lock == true)
                rw_mutex.readLock();
        };

        SharedReadLock(const SharedReadLock &obj)
        {
            obj.reference->operator++();

            this->rw_mutex = obj.rw_mutex;
            this->reference = obj.reference;
            this->locked = obj.locked;
        };

        SharedReadLock(SharedReadLock&&obj)
        {
            //MOVE
            this->rw_mutex = obj.rw_mutex;
            this->reference = obj.reference;
            this->locked = obj.locked;

            //TRUNCATE
            obj.rw_mutex = nullptr;
            obj.reference = nullptr;
            obj.locked = nullptr;
        };

        ~SharedReadLock()
        {
            if (reference == nullptr || reference->operator--() > 0)
                return;

            if (locked->load() == true)
                rw_mutex->readUnlock();

            delete reference;
            delete locked;
        };

        /* -----------------------------------------------------------
            LOCKERS
        ----------------------------------------------------------- */
        void lock() const
        {
            if (locked->load() == true)
                return;

            rw_mutex->readLock();
            locked->store(true);
        };

        void unlock() const
        {
            if (locked->load() == false)
                return;

            rw_mutex->readUnlock();
            locked->store(false);
        };

        //auto tryLock() const -> bool;
    };
};
};