readwritelock.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <shared_mutex>
#include <promeki/namespace.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class ReadWriteLock {
        public:
                class ReadLocker {
                        public:
                                ReadLocker(ReadWriteLock &lock) : _lock(lock) { _lock.lockForRead(); }
 
                                ~ReadLocker() { _lock.unlock(); }
 
                                ReadLocker(const ReadLocker &) = delete;
                                ReadLocker &operator=(const ReadLocker &) = delete;
                                ReadLocker(ReadLocker &&) = delete;
                                ReadLocker &operator=(ReadLocker &&) = delete;
 
                        private:
                                ReadWriteLock &_lock;
                };
 
                class WriteLocker {
                        public:
                                WriteLocker(ReadWriteLock &lock) : _lock(lock) { _lock.lockForWrite(); }
 
                                ~WriteLocker() { _lock.unlock(); }
 
                                WriteLocker(const WriteLocker &) = delete;
                                WriteLocker &operator=(const WriteLocker &) = delete;
                                WriteLocker(WriteLocker &&) = delete;
                                WriteLocker &operator=(WriteLocker &&) = delete;
 
                        private:
                                ReadWriteLock &_lock;
                };
 
                ReadWriteLock() = default;
 
                ~ReadWriteLock() = default;
 
                ReadWriteLock(const ReadWriteLock &) = delete;
                ReadWriteLock &operator=(const ReadWriteLock &) = delete;
                ReadWriteLock(ReadWriteLock &&) = delete;
                ReadWriteLock &operator=(ReadWriteLock &&) = delete;
 
                void lockForRead() { _mutex.lock_shared(); }
 
                void lockForWrite() { _mutex.lock(); }
 
                void unlock() { _mutex.unlock(); }
 
                bool tryLockForRead() { return _mutex.try_lock_shared(); }
 
                bool tryLockForWrite() { return _mutex.try_lock(); }
 
        private:
                std::shared_mutex _mutex;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE