UMutex.h

/*
*  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, bool lockNow = true) :
    mutex_(mutex),
    locked_(false)
  {
    if(lockNow)
    {
      lock();
    }
  }
  // backward compatibility
  UScopeMutex(UMutex * mutex) :
    mutex_(*mutex),
    locked_(false)
  {
    lock();
  }
  ~UScopeMutex()
  {
    unlock();
  }
 
  int lock() &
  {
    if(locked_)
    {
      return 0;
    }
    int r = mutex_.lock();
    locked_ = r == 0;
    return r;
  }
 
#if !defined(_WIN32) || (_WIN32_WINNT >= 0x0400)
  int lockTry() &
  {
    if(locked_)
    {
      return 0;
    }
    int r = mutex_.lockTry();
    locked_ = r == 0;
    return r;
  }
#endif
 
  int unlock() &
  {
    if(!locked_)
    {
      return 0;
    }
    locked_ = false;
    return mutex_.unlock();
  }
 
  bool isLocked() const
  {
    return locked_;
  }
 
private:
  UScopeMutex(const UScopeMutex &);
  void operator=(const UScopeMutex &);
 
private:
  const UMutex & mutex_;
  bool locked_;
};
 
#endif // UMUTEX_H