include/osl/mutex.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef _OSL_MUTEX_HXX_
  21 #define _OSL_MUTEX_HXX_
  22
  23 #ifdef __cplusplus
  24
  25 #include <osl/mutex.h>
  26
  27
  28 namespace osl
  29 {
  30     /** A mutual exclusion synchronization object
  31     */
  32     class SAL_WARN_UNUSED Mutex {
  33
  34     public:
  35         /** Create a thread-local mutex.
  36             @return 0 if the mutex could not be created, otherwise a handle to the mutex.
  37             @see ::osl_createMutex()
  38         */
  39         Mutex()
  40         {
  41             mutex = osl_createMutex();
  42         }
  43
  44         /** Release the OS-structures and free mutex data-structure.
  45             @see ::osl_destroyMutex()
  46         */
  47         ~Mutex()
  48         {
  49             osl_destroyMutex(mutex);
  50         }
  51
  52         /** Acquire the mutex, block if already acquired by another thread.
  53             @return sal_False if system-call fails.
  54             @see ::osl_acquireMutex()
  55         */
  56         sal_Bool acquire()
  57         {
  58             return osl_acquireMutex(mutex);
  59         }
  60
  61         /** Try to acquire the mutex without blocking.
  62             @return sal_False if it could not be acquired.
  63             @see ::osl_tryToAcquireMutex()
  64         */
  65         sal_Bool tryToAcquire()
  66         {
  67             return osl_tryToAcquireMutex(mutex);
  68         }
  69
  70         /** Release the mutex.
  71             @return sal_False if system-call fails.
  72             @see ::osl_releaseMutex()
  73         */
  74         sal_Bool release()
  75         {
  76             return osl_releaseMutex(mutex);
  77         }
  78
  79         /** Returns a global static mutex object.
  80             The global and static mutex object can be used to initialize other
  81             static objects in a thread safe manner.
  82             @return the global mutex object
  83             @see ::osl_getGlobalMutex()
  84         */
  85         static Mutex * getGlobalMutex()
  86         {
  87             return (Mutex *)osl_getGlobalMutex();
  88         }
  89
  90     private:
  91         oslMutex mutex;
  92
  93         /** The underlying oslMutex has no reference count.
  94
  95         Since the underlying oslMutex is not a reference counted object, copy
  96         constructed Mutex may work on an already destructed oslMutex object.
  97
  98         */
  99         Mutex(const Mutex&);
 100
 101         /** The underlying oslMutex has no reference count.
 102
 103         When destructed, the Mutex object destroys the undelying oslMutex,
 104         which might cause severe problems in case it's a temporary object.
 105
 106         */
 107         Mutex(oslMutex Mutex);
 108
 109         /** This assignment operator is private for the same reason as
 110             the copy constructor.
 111         */
 112         Mutex& operator= (const Mutex&);
 113
 114         /** This assignment operator is private for the same reason as
 115             the constructor taking a oslMutex argument.
 116         */
 117         Mutex& operator= (oslMutex);
 118     };
 119
 120     /** A helper class for mutex objects and interfaces.
 121     */
 122     template<class T>
 123     class Guard
 124     {
 125     private:
 126         Guard( const Guard& );
 127         const Guard& operator = ( const Guard& );
 128
 129     protected:
 130         T * pT;
 131     public:
 132
 133         /** Acquires the object specified as parameter.
 134         */
 135         Guard(T * pT_) : pT(pT_)
 136         {
 137             pT->acquire();
 138         }
 139
 140         /** Acquires the object specified as parameter.
 141         */
 142         Guard(T & t) : pT(&t)
 143         {
 144             pT->acquire();
 145         }
 146
 147         /** Releases the mutex or interface. */
 148         ~Guard()
 149         {
 150             pT->release();
 151         }
 152     };
 153
 154     /** A helper class for mutex objects and interfaces.
 155     */
 156     template<class T>
 157     class ClearableGuard
 158     {
 159     private:
 160         ClearableGuard( const ClearableGuard& );
 161         const ClearableGuard& operator = ( const ClearableGuard& );
 162     protected:
 163         T * pT;
 164     public:
 165
 166         /** Acquires the object specified as parameter.
 167         */
 168         ClearableGuard(T * pT_) : pT(pT_)
 169         {
 170             pT->acquire();
 171         }
 172
 173         /** Acquires the object specified as parameter.
 174         */
 175         ClearableGuard(T & t) : pT(&t)
 176         {
 177             pT->acquire();
 178         }
 179
 180         /** Releases the mutex or interface if not already released by clear().
 181         */
 182         ~ClearableGuard()
 183         {
 184             if (pT)
 185                 pT->release();
 186         }
 187
 188         /** Releases the mutex or interface.
 189         */
 190         void clear()
 191         {
 192             if(pT)
 193             {
 194                 pT->release();
 195                 pT = NULL;
 196             }
 197         }
 198     };
 199
 200     /** A helper class for mutex objects and interfaces.
 201     */
 202     template< class T >
 203     class ResettableGuard : public ClearableGuard< T >
 204     {
 205     private:
 206         ResettableGuard(ResettableGuard &); // not defined
 207         void operator =(ResettableGuard &); // not defined
 208
 209     protected:
 210         T* pResetT;
 211     public:
 212         /** Acquires the object specified as parameter.
 213         */
 214         ResettableGuard( T* pT_ ) :
 215                 ClearableGuard<T>( pT_ ),
 216                 pResetT( pT_ )
 217         {}
 218
 219         /** Acquires the object specified as parameter.
 220         */
 221         ResettableGuard( T& rT ) :
 222                 ClearableGuard<T>( rT ),
 223                 pResetT( &rT )
 224         {}
 225
 226         /** Re-aquires the mutex or interface.
 227         */
 228         void reset()
 229         {
 230             if( pResetT )
 231             {
 232                 this->pT = pResetT;
 233                 this->pT->acquire();
 234             }
 235         }
 236     };
 237
 238     typedef Guard<Mutex> MutexGuard;
 239     typedef ClearableGuard<Mutex> ClearableMutexGuard;
 240     typedef ResettableGuard< Mutex > ResettableMutexGuard;
 241 }
 242
 243 #endif  /* __cplusplus */
 244 #endif  /* _OSL_MUTEX_HXX_ */
 245
 246 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */