readwritelock.h

Go to the documentation of this file.

 
#pragma once
 
#include <shared_mutex>
#include <promeki/core/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