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