]> git.tdb.fi Git - libs/core.git/blob - source/core/mutex.h
Drop copyright and license notices from source files
[libs/core.git] / source / core / mutex.h
1 #ifndef MSP_CORE_MUTEX_H_
2 #define MSP_CORE_MUTEX_H_
3
4 #include "refptr.h"
5
6 namespace Msp {
7
8 /**
9 A class for controlling mutually exclusive access to a resource.  Only one
10 thread can hold a lock on the mutex at a time.
11 */
12 class Mutex
13 {
14         friend class Semaphore;
15
16 private:
17         struct Private;
18
19         Private *priv;
20
21 public:
22         Mutex();
23         ~Mutex();
24
25         /** Locks the mutex.  If the mutex is already locked, waits until it becomes
26         available. */
27         void lock();
28
29         /** Attempts to lock the mutex.  Returns true if the lock was acquired,
30         otherwise returns false. */
31         bool trylock();
32
33         /** Unlocks the mutex. */
34         void unlock();
35 };
36
37 /**
38 Locks the mutex for te lifetime of the object.
39 */
40 class MutexLock
41 {
42 private:
43         Mutex &mutex;
44
45 public:
46         MutexLock(Mutex &m, bool l = true): mutex(m) { if(l) mutex.lock(); }
47         ~MutexLock() { mutex.unlock(); }
48
49         void lock() { mutex.lock(); }
50 private:
51         MutexLock(const MutexLock &);
52         MutexLock &operator=(const MutexLock &);
53 };
54
55 /**
56 Protects a pointer with a mutex.  As long as the MutexPtr (or a copy of it)
57 exists, the mutex will stay locked.
58 */
59 template<typename T>
60 class MutexPtr
61 {
62 public:
63         MutexPtr(T *d, Mutex &m): mutex(new MutexLock(m)), data(d) { }
64
65         T &operator*() const { return *data; }
66         T *operator->() const { return data; }
67         void clear() { mutex=0; data = 0; }
68 private:
69         RefPtr<MutexLock> mutex;
70         T *data;
71 };
72
73 /*template<typename T>
74 class MutexPtr: public RefCount
75 {
76 public:
77         MutexPtr(T *d, Mutex &m): mutex(m), data(d) { mutex.lock(); }
78         MutexPtr(const MutexPtr<T> &p): RefCount(p), mutex(p.mutex), data(p.data) { }
79         T &operator*() const { return *data; }
80         T *operator->() const { return data; }
81         void clear() { decref(); data = 0; }
82         ~MutexPtr() { decref(); }
83 protected:
84         Mutex &mutex;
85         T     *data;
86
87         bool decref()
88         {
89                 if(!RefCount::decref())
90                 {
91                         mutex.unlock();
92                         return false;
93                 }
94                 return true;
95         }
96 };*/
97
98 }
99
100 #endif