commit 90a3485ca0e8f459af3002743f9f2ecd03c6a6cb
parent 855eb9f77a2112f8aac4ff9fbb15b8c8b2889673
Author: falkTX <falktx@gmail.com>
Date: Fri, 25 Apr 2014 19:20:46 +0100
Add extra mutex class
Diffstat:
1 file changed, 221 insertions(+), 0 deletions(-)
diff --git a/distrho/extra/d_mutex.hpp b/distrho/extra/d_mutex.hpp
@@ -0,0 +1,221 @@
+/*
+ * DISTRHO Plugin Framework (DPF)
+ * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any purpose with
+ * or without fee is hereby granted, provided that the above copyright notice and this
+ * permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
+ * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
+ * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef DISTRHO_MUTEX_HPP_INCLUDED
+#define DISTRHO_MUTEX_HPP_INCLUDED
+
+#include "../DistrhoUtils.hpp"
+
+#include <pthread.h>
+
+// -----------------------------------------------------------------------
+// d_mutex class
+
+class d_mutex
+{
+public:
+ /*
+ * Constructor.
+ */
+ d_mutex() noexcept
+ {
+ pthread_mutex_init(&fMutex, nullptr);
+ }
+
+ /*
+ * Destructor.
+ */
+ ~d_mutex() noexcept
+ {
+ pthread_mutex_destroy(&fMutex);
+ }
+
+ /*
+ * Lock the mutex.
+ */
+ void lock() const noexcept
+ {
+ pthread_mutex_lock(&fMutex);
+ }
+
+ /*
+ * Try to lock the mutex.
+ * Returns true if successful.
+ */
+ bool tryLock() const noexcept
+ {
+ return (pthread_mutex_trylock(&fMutex) == 0);
+ }
+
+ /*
+ * Unlock the mutex, optionally resetting the tryLock check.
+ */
+ void unlock() const noexcept
+ {
+ pthread_mutex_unlock(&fMutex);
+ }
+
+private:
+ mutable pthread_mutex_t fMutex;
+
+ DISTRHO_PREVENT_HEAP_ALLOCATION
+ DISTRHO_DECLARE_NON_COPY_CLASS(d_mutex)
+};
+
+// -----------------------------------------------------------------------
+// d_rmutex class
+
+class d_rmutex
+{
+public:
+ /*
+ * Constructor.
+ */
+ d_rmutex() noexcept
+ {
+#ifdef DISTRHO_OS_WIN
+ InitializeCriticalSection(&fSection);
+#else
+ pthread_mutexattr_t atts;
+ pthread_mutexattr_init(&atts);
+ pthread_mutexattr_settype(&atts, PTHREAD_MUTEX_RECURSIVE);
+ pthread_mutex_init(&fMutex, &atts);
+ pthread_mutexattr_destroy(&atts);
+#endif
+ }
+
+ /*
+ * Destructor.
+ */
+ ~d_rmutex() noexcept
+ {
+#ifdef DISTRHO_OS_WIN
+ DeleteCriticalSection(&fSection);
+#else
+ pthread_mutex_destroy(&fMutex);
+#endif
+ }
+
+ /*
+ * Lock the mutex.
+ */
+ void lock() const noexcept
+ {
+#ifdef DISTRHO_OS_WIN
+ EnterCriticalSection(&fSection);
+#else
+ pthread_mutex_lock(&fMutex);
+#endif
+ }
+
+ /*
+ * Try to lock the mutex.
+ * Returns true if successful.
+ */
+ bool tryLock() const noexcept
+ {
+#ifdef DISTRHO_OS_WIN
+ return (TryEnterCriticalSection(&fSection) != FALSE);
+#else
+ return (pthread_mutex_trylock(&fMutex) == 0);
+#endif
+ }
+
+ /*
+ * Unlock the mutex.
+ */
+ void unlock() const noexcept
+ {
+#ifdef DISTRHO_OS_WIN
+ LeaveCriticalSection(&fSection);
+#else
+ pthread_mutex_unlock(&fMutex);
+#endif
+ }
+
+private:
+#ifdef DISTRHO_OS_WIN
+ mutable CRITICAL_SECTION fSection;
+#else
+ mutable pthread_mutex_t fMutex;
+#endif
+
+ DISTRHO_PREVENT_HEAP_ALLOCATION
+ DISTRHO_DECLARE_NON_COPY_CLASS(d_rmutex)
+};
+
+// -----------------------------------------------------------------------
+// Helper class to lock&unlock a mutex during a function scope.
+
+template <class Mutex>
+class d_scopeLocker
+{
+public:
+ d_scopeLocker(const Mutex& mutex) noexcept
+ : fMutex(mutex)
+ {
+ fMutex.lock();
+ }
+
+ ~d_scopeLocker() noexcept
+ {
+ fMutex.unlock();
+ }
+
+private:
+ const Mutex& fMutex;
+
+ DISTRHO_PREVENT_HEAP_ALLOCATION
+ DISTRHO_DECLARE_NON_COPY_CLASS(d_scopeLocker)
+};
+
+// -----------------------------------------------------------------------
+// Helper class to unlock&lock a mutex during a function scope.
+
+template <class Mutex>
+class d_scopeUnlocker
+{
+public:
+ d_scopeUnlocker(const Mutex& mutex) noexcept
+ : fMutex(mutex)
+ {
+ fMutex.unlock();
+ }
+
+ ~d_scopeUnlocker() noexcept
+ {
+ fMutex.lock();
+ }
+
+private:
+ const Mutex& fMutex;
+
+ DISTRHO_PREVENT_HEAP_ALLOCATION
+ DISTRHO_DECLARE_NON_COPY_CLASS(d_scopeUnlocker)
+};
+
+// -----------------------------------------------------------------------
+// Define types
+
+typedef d_scopeLocker<d_mutex> d_mutexLocker;
+typedef d_scopeLocker<d_rmutex> d_rmutexLocker;
+
+typedef d_scopeUnlocker<d_mutex> d_mutexUnlocker;
+typedef d_scopeUnlocker<d_rmutex> d_rmutexUnlocker;
+
+// -----------------------------------------------------------------------
+
+#endif // DISTRHO_MUTEX_HPP_INCLUDED
