framework/delibs/decpp/deMutex.hpp

   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
  29 namespace de
  30 {
  31
  32 /*--------------------------------------------------------------------*//*!
  33  * \brief Mutual exclusion lock
  34  *
  35  * Mutex class provides standard mutual exclusion lock functionality.
  36  *//*--------------------------------------------------------------------*/
  37 class Mutex
  38 {
  39 public:
  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
  47 private:
  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  *//*--------------------------------------------------------------------*/
  61 class ScopedLock
  62 {
  63 public:
  64                                         ScopedLock              (Mutex& mutex);
  65                                         ~ScopedLock             (void) { m_mutex.unlock(); }
  66
  67 private:
  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  *//*--------------------------------------------------------------------*/
  88 inline 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  *//*--------------------------------------------------------------------*/
 102 inline 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  *//*--------------------------------------------------------------------*/
 114 inline 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  *//*--------------------------------------------------------------------*/
 125 inline ScopedLock::ScopedLock (Mutex& mutex)
 126         : m_mutex(mutex)
 127 {
 128         m_mutex.lock();
 129 }
 130
 131 } // de
 132
 133 #endif // _DEMUTEX_HPP