mutex.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_MUTEX_HPP
#define JOIN_CORE_MUTEX_HPP
 
// C.
#include <pthread.h>
 
namespace join
{
    class Mutex
    {
    public:
        explicit Mutex (bool inherit = false);
 
        Mutex (const Mutex& other) = delete;
 
        Mutex& operator= (const Mutex& other) = delete;
 
        Mutex (Mutex&& other) = delete;
 
        Mutex& operator= (Mutex&& other) = delete;
 
        ~Mutex ();
 
        void lock () noexcept;
 
        bool tryLock () noexcept;
 
        void unlock () noexcept;
 
        pthread_mutex_t* handle () noexcept;
 
    private:
        pthread_mutex_t _handle;
    };
 
    class RecursiveMutex
    {
    public:
        explicit RecursiveMutex (bool inherit = false);
 
        RecursiveMutex (const Mutex& other) = delete;
 
        RecursiveMutex& operator= (const RecursiveMutex& other) = delete;
 
        RecursiveMutex (RecursiveMutex&& other) = delete;
 
        RecursiveMutex& operator= (RecursiveMutex&& other) = delete;
 
        ~RecursiveMutex ();
 
        void lock () noexcept;
 
        bool tryLock () noexcept;
 
        void unlock () noexcept;
 
        pthread_mutex_t* handle () noexcept;
 
    private:
        pthread_mutex_t _handle;
    };
 
    class SharedMutex
    {
    public:
        explicit SharedMutex (bool inherit = false);
 
        SharedMutex (const SharedMutex& other) = delete;
 
        SharedMutex& operator= (const SharedMutex& other) = delete;
 
        SharedMutex (SharedMutex&& other) = delete;
 
        SharedMutex& operator= (SharedMutex&& other) = delete;
 
        ~SharedMutex ();
 
        void lock () noexcept;
 
        bool tryLock () noexcept;
 
        void unlock () noexcept;
 
        pthread_mutex_t* handle () noexcept;
 
    private:
        pthread_mutex_t _handle;
    };
 
    template <typename Lockable>
    class ScopedLock
    {
    public:
        ScopedLock () = delete;
 
        explicit ScopedLock (Lockable& mutex)
        : _mutex (mutex)
        {
            _mutex.lock ();
        }
 
        ScopedLock (const ScopedLock& other) = delete;
 
        ScopedLock& operator= (const ScopedLock& other) = delete;
 
        ScopedLock (ScopedLock&& other) = delete;
 
        ScopedLock& operator= (ScopedLock&& other) = delete;
 
        ~ScopedLock ()
        {
            _mutex.unlock ();
        }
 
        Lockable* mutex () const
        {
            return &_mutex;
        }
 
    private:
        Lockable& _mutex;
    };
}
 
#endif