ReaderWriterLock.h

 
#pragma once
 
#include <aws/core/Core_EXPORTS.h>
#include <aws/core/utils/threading/Semaphore.h>
#include <mutex>
#include <atomic>
#include <condition_variable>
#include <cstdint>
 
namespace Aws
{
    namespace Utils
    {
        namespace Threading
        {
            class AWS_CORE_API ReaderWriterLock
            {
            public:
                ReaderWriterLock();
                void LockReader();
 
                void UnlockReader();
 
                void LockWriter();
 
                void UnlockWriter();
            private:
                std::atomic<int64_t> m_readers;
                std::atomic<int64_t> m_holdouts;
                Semaphore m_readerSem;
                Semaphore m_writerSem;
                std::mutex m_writerLock;
            };
 
            class AWS_CORE_API ReaderLockGuard
            {
            public:
                explicit ReaderLockGuard(ReaderWriterLock& rwl) : m_rwlock(rwl), m_upgraded(false)
                {
                    m_rwlock.LockReader();
                }
 
                void UpgradeToWriterLock()
                {
                    m_rwlock.UnlockReader();
                    m_rwlock.LockWriter();
                    m_upgraded = true;
                }
 
                ~ReaderLockGuard()
                {
                    if(m_upgraded)
                    {
                        m_rwlock.UnlockWriter();
                    }
                    else
                    {
                        m_rwlock.UnlockReader();
                    }
                }
                // for VS2013
                ReaderLockGuard(const ReaderLockGuard&) = delete;
                ReaderLockGuard& operator=(const ReaderLockGuard&) = delete;
            private:
                ReaderWriterLock& m_rwlock;
                bool m_upgraded;
            };
 
            class AWS_CORE_API WriterLockGuard
            {
            public:
                explicit WriterLockGuard(ReaderWriterLock& rwl) : m_rwlock(rwl)
                {
                    m_rwlock.LockWriter();
                }
 
                ~WriterLockGuard()
                {
                    m_rwlock.UnlockWriter();
                }
                // for VS2013
                WriterLockGuard(const WriterLockGuard&) = delete;
                WriterLockGuard& operator=(const WriterLockGuard&) = delete;
            private:
                ReaderWriterLock& m_rwlock;
            };
        }
    }
}