.. _program_listing_file__tmp_ws_src_find_object_2d_include_find_object_utilite_UMutex.h:

Program Listing for File UMutex.h
=================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_find_object_2d_include_find_object_utilite_UMutex.h>` (``/tmp/ws/src/find_object_2d/include/find_object/utilite/UMutex.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /*
   *  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 "find_object/utilite/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