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 INCLUDED_OSL_MUTEX_HXX
21#define INCLUDED_OSL_MUTEX_HXX
22
23#ifdef __cplusplus
24
25#include <osl/mutex.h>
26
27
28namespace osl
29{
30 /** A mutual exclusion synchronization object
31 */
32 class SAL_WARN_UNUSED Mutex {
33
34 public:
35 /** Create a 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 false if system-call fails.
54 @see ::osl_acquireMutex()
55 */
56 bool acquire()
57 {
58 return osl_acquireMutex(mutex);
59 }
60
61 /** Try to acquire the mutex without blocking.
62 @return false if it could not be acquired.
63 @see ::osl_tryToAcquireMutex()
64 */
65 bool tryToAcquire()
66 {
67 return osl_tryToAcquireMutex(mutex);
68 }
69
70 /** Release the mutex.
71 @return false if system-call fails.
72 @see ::osl_releaseMutex()
73 */
74 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 // INCLUDED_OSL_MUTEX_HXX
245
246/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
247