RWLock.hxx

#pragma once
 
// POSIX
#include <pthread.h>
 
// C++
#include <cassert>
 
// cosmos
#include <cosmos/error/ApiError.hxx>
#include <cosmos/utils.hxx>
 
namespace cosmos {
 
 
class RWLock {
        // forbid copy-assignment
        RWLock(const RWLock&) = delete;
        RWLock& operator=(const RWLock&) = delete;
public: // functions
 
        RWLock() {
                if (::pthread_rwlock_init( &m_prwlock, nullptr) != 0) {
                        cosmos_throw (ApiError("pthread_rwlock_init()"));
                }
        }
 
        ~RWLock() {
                const auto destroy_res = ::pthread_rwlock_destroy(&m_prwlock);
 
                assert (!destroy_res);
                (void)destroy_res;
        }
 
        void readlock() const {
                if (::pthread_rwlock_rdlock(&m_prwlock) != 0) {
                        cosmos_throw (ApiError("pthread_rwlock_rdlock()"));
                }
        }
 
        void writelock() const {
                if (::pthread_rwlock_wrlock(&m_prwlock) != 0) {
                        cosmos_throw (ApiError("pthread_rwlock_wrlock()"));
                }
        }
 
        void unlock() const {
                if (::pthread_rwlock_unlock(&m_prwlock) != 0) {
                        cosmos_throw (ApiError("pthread_rwlock_unlock()"));
                }
        }
 
protected: // data
 
        // make that mutable to make const lock/unlock semantics possible
        mutable pthread_rwlock_t m_prwlock;
};
 
struct ReadLockGuard :
                public ResourceGuard<const RWLock&> {
 
        explicit ReadLockGuard(const RWLock &rwl) :
                        ResourceGuard{rwl, [](const RWLock &_rwl) { _rwl.unlock(); }} {
                rwl.readlock();
        }
};
 
struct WriteLockGuard :
                public ResourceGuard<const RWLock&> {
 
        explicit WriteLockGuard(const RWLock &rwl) :
                ResourceGuard{rwl, [](const RWLock &_rwl) { _rwl.unlock(); }} {
                rwl.writelock();
        }
};
 
} // end ns