sal/inc/osl/mutex.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: mutex.hxx,v $
  10  * $Revision: 1.14 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef _OSL_MUTEX_HXX_
  32 #define _OSL_MUTEX_HXX_
  33
  34 #ifdef __cplusplus
  35
  36 #include <osl/mutex.h>
  37
  38
  39 namespace osl
  40 {
  41     /** A mutual exclusion synchronization object
  42     */
  43     class Mutex {
  44
  45     public:
  46         /** Create a thread-local mutex.
  47             @return 0 if the mutex could not be created, otherwise a handle to the mutex.
  48             @seealso ::osl_createMutex()
  49         */
  50         Mutex()
  51         {
  52             mutex = osl_createMutex();
  53         }
  54
  55         /** Release the OS-structures and free mutex data-structure.
  56             @seealso ::osl_destroyMutex()
  57         */
  58         ~Mutex()
  59         {
  60             osl_destroyMutex(mutex);
  61         }
  62
  63         /** Acquire the mutex, block if already acquired by another thread.
  64             @return sal_False if system-call fails.
  65             @seealso ::osl_acquireMutex()
  66         */
  67         sal_Bool acquire()
  68         {
  69             return osl_acquireMutex(mutex);
  70         }
  71
  72         /** Try to acquire the mutex without blocking.
  73             @return sal_False if it could not be acquired.
  74             @seealso ::osl_tryToAcquireMutex()
  75         */
  76         sal_Bool tryToAcquire()
  77         {
  78             return osl_tryToAcquireMutex(mutex);
  79         }
  80
  81         /** Release the mutex.
  82             @return sal_False if system-call fails.
  83             @seealso ::osl_releaseMutex()
  84         */
  85         sal_Bool release()
  86         {
  87             return osl_releaseMutex(mutex);
  88         }
  89
  90         /** Returns a global static mutex object.
  91             The global and static mutex object can be used to initialize other
  92             static objects in a thread safe manner.
  93             @return the global mutex object
  94             @seealso ::osl_getGlobalMutex()
  95         */
  96         static Mutex * getGlobalMutex()
  97         {
  98             return (Mutex *)osl_getGlobalMutex();
  99         }
 100
 101     private:
 102         oslMutex mutex;
 103
 104         /** The underlying oslMutex has no reference count.
 105
 106         Since the underlying oslMutex is not a reference counted object, copy
 107         constructed Mutex may work on an already destructed oslMutex object.
 108
 109         */
 110         Mutex(const Mutex&);
 111
 112         /** The underlying oslMutex has no reference count.
 113
 114         When destructed, the Mutex object destroys the undelying oslMutex,
 115         which might cause severe problems in case it's a temporary object.
 116
 117         */
 118         Mutex(oslMutex Mutex);
 119
 120         /** This assignment operator is private for the same reason as
 121             the copy constructor.
 122         */
 123         Mutex& operator= (const Mutex&);
 124
 125         /** This assignment operator is private for the same reason as
 126             the constructor taking a oslMutex argument.
 127         */
 128         Mutex& operator= (oslMutex);
 129     };
 130
 131     /** A helper class for mutex objects and interfaces.
 132     */
 133     template<class T>
 134     class Guard
 135     {
 136     private:
 137         Guard( const Guard& );
 138         const Guard& operator = ( const Guard& );
 139
 140     protected:
 141         T * pT;
 142     public:
 143
 144         /** Acquires the object specified as parameter.
 145         */
 146         Guard(T * pT_) : pT(pT_)
 147         {
 148             pT->acquire();
 149         }
 150
 151         /** Acquires the object specified as parameter.
 152         */
 153         Guard(T & t) : pT(&t)
 154         {
 155             pT->acquire();
 156         }
 157
 158         /** Releases the mutex or interface. */
 159         ~Guard()
 160         {
 161             pT->release();
 162         }
 163     };
 164
 165     /** A helper class for mutex objects and interfaces.
 166     */
 167     template<class T>
 168     class ClearableGuard
 169     {
 170     private:
 171         ClearableGuard( const ClearableGuard& );
 172         const ClearableGuard& operator = ( const ClearableGuard& );
 173     protected:
 174         T * pT;
 175     public:
 176
 177         /** Acquires the object specified as parameter.
 178         */
 179         ClearableGuard(T * pT_) : pT(pT_)
 180         {
 181             pT->acquire();
 182         }
 183
 184         /** Acquires the object specified as parameter.
 185         */
 186         ClearableGuard(T & t) : pT(&t)
 187         {
 188             pT->acquire();
 189         }
 190
 191         /** Releases the mutex or interface if not already released by clear().
 192         */
 193         ~ClearableGuard()
 194         {
 195             if (pT)
 196                 pT->release();
 197         }
 198
 199         /** Releases the mutex or interface.
 200         */
 201         void clear()
 202         {
 203             if(pT)
 204             {
 205                 pT->release();
 206                 pT = NULL;
 207             }
 208         }
 209     };
 210
 211     /** A helper class for mutex objects and interfaces.
 212     */
 213     template< class T >
 214     class ResettableGuard : public ClearableGuard< T >
 215     {
 216     private:
 217         ResettableGuard(ResettableGuard &); // not defined
 218         void operator =(ResettableGuard &); // not defined
 219
 220     protected:
 221         T* pResetT;
 222     public:
 223         /** Acquires the object specified as parameter.
 224         */
 225         ResettableGuard( T* pT_ ) :
 226                 ClearableGuard<T>( pT_ ),
 227                 pResetT( pT_ )
 228         {}
 229
 230         /** Acquires the object specified as parameter.
 231         */
 232         ResettableGuard( T& rT ) :
 233                 ClearableGuard<T>( rT ),
 234                 pResetT( &rT )
 235         {}
 236
 237         /** Re-aquires the mutex or interface.
 238         */
 239         void reset()
 240         {
 241             if( pResetT )
 242             {
 243                 this->pT = pResetT;
 244                 this->pT->acquire();
 245             }
 246         }
 247     };
 248
 249     typedef Guard<Mutex> MutexGuard;
 250     typedef ClearableGuard<Mutex> ClearableMutexGuard;
 251     typedef ResettableGuard< Mutex > ResettableMutexGuard;
 252 }
 253
 254 #endif  /* __cplusplus */
 255 #endif  /* _OSL_MUTEX_HXX_ */
 256