libs/appleutility/CoreAudio/PublicUtility/CAMutex.h

   1 /*
   2      File: CAMutex.h
   3  Abstract: Part of CoreAudio Utility Classes
   4   Version: 1.1
   5
   6  Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple
   7  Inc. ("Apple") in consideration of your agreement to the following
   8  terms, and your use, installation, modification or redistribution of
   9  this Apple software constitutes acceptance of these terms.  If you do
  10  not agree with these terms, please do not use, install, modify or
  11  redistribute this Apple software.
  12
  13  In consideration of your agreement to abide by the following terms, and
  14  subject to these terms, Apple grants you a personal, non-exclusive
  15  license, under Apple's copyrights in this original Apple software (the
  16  "Apple Software"), to use, reproduce, modify and redistribute the Apple
  17  Software, with or without modifications, in source and/or binary forms;
  18  provided that if you redistribute the Apple Software in its entirety and
  19  without modifications, you must retain this notice and the following
  20  text and disclaimers in all such redistributions of the Apple Software.
  21  Neither the name, trademarks, service marks or logos of Apple Inc. may
  22  be used to endorse or promote products derived from the Apple Software
  23  without specific prior written permission from Apple.  Except as
  24  expressly stated in this notice, no other rights or licenses, express or
  25  implied, are granted by Apple herein, including but not limited to any
  26  patent rights that may be infringed by your derivative works or by other
  27  works in which the Apple Software may be incorporated.
  28
  29  The Apple Software is provided by Apple on an "AS IS" basis.  APPLE
  30  MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
  31  THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
  32  FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
  33  OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
  34
  35  IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
  36  OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  37  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  38  INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
  39  MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
  40  AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
  41  STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
  42  POSSIBILITY OF SUCH DAMAGE.
  43
  44  Copyright (C) 2014 Apple Inc. All Rights Reserved.
  45
  46 */
  47 #ifndef __CAMutex_h__
  48 #define __CAMutex_h__
  49
  50 //==================================================================================================
  51 //      Includes
  52 //==================================================================================================
  53
  54 //      System Includes
  55 #if !defined(__COREAUDIO_USE_FLAT_INCLUDES__)
  56         #include <CoreAudio/CoreAudioTypes.h>
  57 #else
  58         #include <CoreAudioTypes.h>
  59 #endif
  60
  61 #if TARGET_OS_MAC
  62         #include <pthread.h>
  63 #elif TARGET_OS_WIN32
  64         #include <windows.h>
  65 #else
  66         #error  Unsupported operating system
  67 #endif
  68
  69 //==================================================================================================
  70 //      A recursive mutex.
  71 //==================================================================================================
  72
  73 class   CAMutex
  74 {
  75 //      Construction/Destruction
  76 public:
  77                                         CAMutex(const char* inName);
  78         virtual                 ~CAMutex();
  79
  80 //      Actions
  81 public:
  82         virtual bool    Lock();
  83         virtual void    Unlock();
  84         virtual bool    Try(bool& outWasLocked);        // returns true if lock is free, false if not
  85
  86         virtual bool    IsFree() const;
  87         virtual bool    IsOwnedByCurrentThread() const;
  88
  89 //      Implementation
  90 protected:
  91         const char*             mName;
  92 #if TARGET_OS_MAC
  93         pthread_t               mOwner;
  94         pthread_mutex_t mMutex;
  95 #elif TARGET_OS_WIN32
  96         UInt32                  mOwner;
  97         HANDLE                  mMutex;
  98 #endif
  99
 100 //      Helper class to manage taking and releasing recursively
 101 public:
 102         class                   Locker
 103         {
 104
 105         //      Construction/Destruction
 106         public:
 107                                         Locker(CAMutex& inMutex) : mMutex(&inMutex), mNeedsRelease(false) { mNeedsRelease = mMutex->Lock(); }
 108                                         Locker(CAMutex* inMutex) : mMutex(inMutex), mNeedsRelease(false) { mNeedsRelease = (mMutex != NULL && mMutex->Lock()); }
 109                                                 // in this case the mutex can be null
 110                                         ~Locker() { if(mNeedsRelease) { mMutex->Unlock(); } }
 111
 112
 113         private:
 114                                         Locker(const Locker&);
 115                 Locker&         operator=(const Locker&);
 116
 117         //      Implementation
 118         private:
 119                 CAMutex*        mMutex;
 120                 bool            mNeedsRelease;
 121
 122         };
 123
 124 // Unlocker
 125         class Unlocker
 126         {
 127         public:
 128                                                 Unlocker(CAMutex& inMutex);
 129                                                 ~Unlocker();
 130
 131         private:
 132                 CAMutex&        mMutex;
 133                 bool            mNeedsLock;
 134
 135                 // Hidden definitions of copy ctor, assignment operator
 136                 Unlocker(const Unlocker& copy);                         // Not implemented
 137                 Unlocker& operator=(const Unlocker& copy);      // Not implemented
 138         };
 139
 140 // you can use this with Try - if you take the lock in try, pass in the outWasLocked var
 141         class Tryer {
 142
 143         //      Construction/Destruction
 144         public:
 145                 Tryer (CAMutex &mutex) : mMutex(mutex), mNeedsRelease(false), mHasLock(false) { mHasLock = mMutex.Try (mNeedsRelease); }
 146                 ~Tryer () { if (mNeedsRelease) mMutex.Unlock(); }
 147
 148                 bool HasLock () const { return mHasLock; }
 149
 150         private:
 151                                         Tryer(const Tryer&);
 152                 Tryer&          operator=(const Tryer&);
 153
 154         //      Implementation
 155         private:
 156                 CAMutex &               mMutex;
 157                 bool                    mNeedsRelease;
 158                 bool                    mHasLock;
 159         };
 160 };
 161
 162
 163 #endif // __CAMutex_h__