mutex.h

#pragma once

#include <boost/noncopyable.hpp>
#include <boost/thread/mutex.hpp>
// Note: if one wants to use nested mutex, use this one. However, it is slightly heavier than traditional mutex. On windows, mutex can be nested by default. 
// #include <boost/thread/recursive_mutex.hpp>

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_;
    };

    template <typename Mutex>
    class no_lock{
    public:
        no_lock(Mutex& m){}
        bool locked() const { return true; };
        void unlock() {};
    };

    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;
        }

    };
    typedef mutex::ScopedLock Lock;
}