Mutex.hxx

#pragma once
 
// POSIX
#include <pthread.h>
 
// C++
#include <cassert>
 
// cosmos
#include <cosmos/dso_export.h>
#include <cosmos/error/ApiError.hxx>
#include <cosmos/utils.hxx>
 
namespace cosmos {
 
// fwd. decl.
class Condition;
 
 
class COSMOS_API Mutex {
        // disallow copy/assignment
        Mutex(const Mutex&) = delete;
        Mutex& operator=(const Mutex&) = delete;
 
public: // functions
 
 
        Mutex();
 
        ~Mutex() {
                const auto destroy_res = ::pthread_mutex_destroy(&m_pmutex);
 
                assert (!destroy_res);
                (void)destroy_res;
        }
 
        void lock() const {
                const auto lock_res = ::pthread_mutex_lock(&m_pmutex);
 
                if (lock_res) {
                        cosmos_throw (ApiError("pthread_mutex_lock()", Errno{lock_res}));
                }
        }
 
        void unlock() const {
                const int unlock_res = ::pthread_mutex_unlock(&m_pmutex);
 
                if (unlock_res) {
                        cosmos_throw (ApiError("pthread_mutex_unlock()", Errno{unlock_res}));
                }
        }
 
protected: // data
 
        // make that mutable to make const lock/unlock semantics possible
        mutable pthread_mutex_t m_pmutex;
 
        // Condition needs access to our handle
        friend class Condition;
};
 
struct MutexGuard :
                public ResourceGuard<const Mutex&> {
 
        explicit MutexGuard(const Mutex &m) :
                        ResourceGuard{m, [](const Mutex &_m) { _m.unlock(); }} {
                m.lock();
        }
};
 
struct MutexReverseGuard :
                public ResourceGuard<const Mutex&> {
 
        explicit MutexReverseGuard(const Mutex &m) :
                        ResourceGuard{m, [](const Mutex &_m) { _m.lock(); }} {
                m.unlock();
        }
};
 
} // end ns