UMutex.h

Go to the documentation of this file.

/*
*  utilite is a cross-platform library with
*  useful utilities for fast and small developing.
*  Copyright (C) 2010  Mathieu Labbe
*
*  utilite is free library: you can redistribute it and/or modify
*  it under the terms of the GNU Lesser General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  utilite is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU Lesser General Public License for more details.
*
*  You should have received a copy of the GNU Lesser General Public License
*  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef UMUTEX_H
#define UMUTEX_H
 
#include <errno.h>
 
#ifdef _WIN32
  #include "rtabmap/utilite/Win32/UWin32.h"
#else
  #include <pthread.h>
#endif
 
 
class UMutex
{
 
public:
 
        UMutex()
        {
#ifdef _WIN32
                InitializeCriticalSection(&C);
#else
                pthread_mutexattr_t attr;
                pthread_mutexattr_init(&attr);
                pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
                pthread_mutex_init(&M,&attr);
                pthread_mutexattr_destroy(&attr);
#endif
        }
 
        virtual ~UMutex()
        {
#ifdef _WIN32
                DeleteCriticalSection(&C);
#else
                pthread_mutex_unlock(&M); pthread_mutex_destroy(&M);
#endif
        }
 
        int lock() const
        {
#ifdef _WIN32
                EnterCriticalSection(&C); return 0;
#else
                return pthread_mutex_lock(&M);
#endif
        }
 
#ifdef _WIN32
        #if(_WIN32_WINNT >= 0x0400)
        int lockTry() const
        {
                return (TryEnterCriticalSection(&C)?0:EBUSY);
        }
        #endif
#else
        int lockTry() const
        {
                return pthread_mutex_trylock(&M);
        }
#endif
 
        int unlock() const
        {
#ifdef _WIN32
                LeaveCriticalSection(&C); return 0;
#else
                return pthread_mutex_unlock(&M);
#endif
        }
 
        private:
#ifdef _WIN32
                mutable CRITICAL_SECTION C;
#else
                mutable pthread_mutex_t M;
#endif
                void operator=(UMutex &) {}
                UMutex( const UMutex & ) {}
};
 
class UScopeMutex
{
public:
        UScopeMutex(const UMutex & mutex) :
                mutex_(mutex)
        {
                mutex_.lock();
        }
        // backward compatibility
        UScopeMutex(UMutex * mutex) :
                mutex_(*mutex)
        {
                mutex_.lock();
        }
        ~UScopeMutex()
        {
                mutex_.unlock();
        }
private:
        const UMutex & mutex_;
};
 
#endif // UMUTEX_H