deMutex.hpp revision 3c827367444ee418f129b2c238299f49d3264554 
1#ifndef _DEMUTEX_HPP
2#define _DEMUTEX_HPP
3/*-------------------------------------------------------------------------
4 * drawElements C++ Base Library
5 * -----------------------------
6 *
7 * Copyright 2014 The Android Open Source Project
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 *      http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 *
21 *//*!
22 * \file
23 * \brief deMutex C++ wrapper.
24 *//*--------------------------------------------------------------------*/
25
26#include "deDefs.hpp"
27#include "deMutex.h"
28
29namespace de
30{
31
32/*--------------------------------------------------------------------*//*!
33 * \brief Mutual exclusion lock
34 *
35 * Mutex class provides standard mutual exclusion lock functionality.
36 *//*--------------------------------------------------------------------*/
37class Mutex
38{
39public:
40					Mutex			(deUint32 flags = 0);
41					~Mutex			(void);
42
43	void			lock			(void) throw();
44	void			unlock			(void) throw();
45	bool			tryLock			(void) throw();
46
47private:
48					Mutex			(const Mutex& other); // Not allowed!
49	Mutex&			operator=		(const Mutex& other); // Not allowed!
50
51	deMutex			m_mutex;
52};
53
54/*--------------------------------------------------------------------*//*!
55 * \brief Scoped mutex lock.
56 *
57 * ScopedLock provides helper for maintaining Mutex lock for the duration
58 * of current scope. The lock is acquired in constructor and released
59 * when ScopedLock goes out of scope.
60 *//*--------------------------------------------------------------------*/
61class ScopedLock
62{
63public:
64					ScopedLock		(Mutex& mutex);
65					~ScopedLock		(void) { m_mutex.unlock(); }
66
67private:
68					ScopedLock		(const ScopedLock& other); // Not allowed!
69	ScopedLock&		operator=		(const ScopedLock& other); // Not allowed!
70
71	Mutex&			m_mutex;
72};
73
74// Mutex inline implementations.
75
76/*--------------------------------------------------------------------*//*!
77 * \brief Acquire mutex lock.
78 * \note This method will never report failure. If an error occurs due
79 *		 to misuse or other reason it will lead to process termination
80*		 in debug build.
81 *
82 * If mutex is currently locked the function will block until current
83 * lock is released.
84 *
85 * In recursive mode further calls from the thread owning the mutex will
86 * succeed and increment lock count.
87 *//*--------------------------------------------------------------------*/
88inline void Mutex::lock (void) throw()
89{
90	deMutex_lock(m_mutex);
91}
92
93/*--------------------------------------------------------------------*//*!
94 * \brief Release mutex lock.
95 * \note This method will never report failure. If an error occurs due
96 *		 to misuse or other reason it will lead to process termination
97*		 in debug build.
98 *
99 * In recursive mode the mutex will be released once the lock count reaches
100 * zero.
101 *//*--------------------------------------------------------------------*/
102inline void Mutex::unlock (void) throw()
103{
104	deMutex_unlock(m_mutex);
105}
106
107/*--------------------------------------------------------------------*//*!
108 * \brief Try to acquire lock.
109 * \return Returns true if lock was acquired and false otherwise.
110 *
111 * This function will never block, i.e. it will return false if mutex
112 * is currently locked.
113 *//*--------------------------------------------------------------------*/
114inline bool Mutex::tryLock (void) throw()
115{
116	return deMutex_tryLock(m_mutex) == DE_TRUE;
117}
118
119// ScopedLock inline implementations.
120
121/*--------------------------------------------------------------------*//*!
122 * \brief Acquire scoped lock to mutex.
123 * \param mutex Mutex to be locked.
124 *//*--------------------------------------------------------------------*/
125inline ScopedLock::ScopedLock (Mutex& mutex)
126	: m_mutex(mutex)
127{
128	m_mutex.lock();
129}
130
131} // de
132
133#endif // _DEMUTEX_HPP
134