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 &M) {}
                UMutex( const UMutex &M ) {}
};

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