Mutex.hpp

#pragma once

// Use Window or Posix
#ifdef WIN32
#include <windows.h>
#else
#include <pthread.h>
#endif

namespace ParaEngine
{
    template <typename Mutex>
    class Scoped_Lock
    {
    public:
        // Constructor acquires the lock.
        Scoped_Lock(Mutex& m)
            : mutex_(m)
        {
            mutex_.lock();
            locked_ = true;
        }

        // Destructor releases the lock.
        ~Scoped_Lock()
        {
            if (locked_)
                mutex_.unlock();
        }

        // Explicitly acquire the lock.
        void lock()
        {
            if (!locked_)
            {
                mutex_.lock();
                locked_ = true;
            }
        }

        // Explicitly release the lock.
        void unlock()
        {
            if (locked_)
            {
                mutex_.unlock();
                locked_ = false;
            }
        }

        // Test whether the lock is held.
        bool locked() const
        {
            return locked_;
        }

        // Get the underlying mutex.
        Mutex& mutex()
        {
            return mutex_;
        }

    private:
        // The underlying mutex.
        Mutex& mutex_;

        // Whether the mutex is currently locked or unlocked.
        bool locked_;
    };

    class Mutex
    {
    public:
        typedef Scoped_Lock<Mutex>  ScopedLock;
    private:

#ifdef WIN32
        CRITICAL_SECTION _mutex; 
#else
        pthread_mutex_t _mutex; 
#endif

        bool _locked;           
        void init(){
#ifdef WIN32
            InitializeCriticalSection(&_mutex);
#else
            pthread_mutexattr_t attr;
            pthread_mutexattr_init(&attr);
            pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
            pthread_mutex_init(&_mutex,&attr);
            pthread_mutexattr_destroy(&attr);
#endif
            _locked = false;
        }

    public:

        Mutex(){
            init();
        }
        Mutex( const Mutex &in_mutex ) {
            init();

            if(in_mutex._locked && !_locked) lock();
            else if(!in_mutex._locked && _locked) unlock();
        }

        Mutex& operator=(const Mutex &in_mutex) {
            if(in_mutex._locked && !_locked) lock();
            else if(!in_mutex._locked && _locked) unlock();
            return *this;
        }

        virtual ~Mutex(){
#ifdef WIN32
            DeleteCriticalSection(&_mutex);
#else
            pthread_mutex_unlock(&_mutex);
            pthread_mutex_destroy(&_mutex);
#endif
        }

        bool lock(){
            _locked = true;
#ifdef WIN32
            EnterCriticalSection(&_mutex);
            return true;
#else
            return pthread_mutex_lock(&_mutex) == 0;
#endif
        }

        bool tryLock(){
            _locked = true;
#ifdef WIN32
            return !!TryEnterCriticalSection(&_mutex);
#else
            return pthread_mutex_trylock(&_mutex) == 0;
#endif
        }

        bool unlock(){
            _locked = false;
#ifdef WIN32
            LeaveCriticalSection(&_mutex);
            return true;
#else
            return pthread_mutex_unlock(&_mutex) == 0;
#endif
        }

        bool isLocked() const{
            return _locked;
        }

    };
}