commit 8fb0b54755f3ca46548a2cd54bd89f520e27d19f
parent bb52beae467b04a82095ac225f09a06d9e2e0b4e
Author: falkTX <falktx@gmail.com>
Date: Mon, 12 May 2014 22:50:29 +0100
Add d_mutex.hpp file, for a 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>
+
+// -----------------------------------------------------------------------
+// Mutex class
+
+class Mutex
+{
+public:
+ /*
+ * Constructor.
+ */
+ Mutex() noexcept
+ {
+ pthread_mutex_init(&fMutex, nullptr);
+ }
+
+ /*
+ * Destructor.
+ */
+ ~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.
+ */
+ void unlock() const noexcept
+ {
+ pthread_mutex_unlock(&fMutex);
+ }
+
+private:
+ mutable pthread_mutex_t fMutex;
+
+ DISTRHO_PREVENT_HEAP_ALLOCATION
+ DISTRHO_DECLARE_NON_COPY_CLASS(Mutex)
+};
+
+// -----------------------------------------------------------------------
+// RecursiveMutex class
+
+class RecursiveMutex
+{
+public:
+ /*
+ * Constructor.
+ */
+ RecursiveMutex() noexcept
+ {
+#ifdef DISTRHO_OS_WINDOWS
+ 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.
+ */
+ ~RecursiveMutex() noexcept
+ {
+#ifdef DISTRHO_OS_WINDOWS
+ DeleteCriticalSection(&fSection);
+#else
+ pthread_mutex_destroy(&fMutex);
+#endif
+ }
+
+ /*
+ * Lock the mutex.
+ */
+ void lock() const noexcept
+ {
+#ifdef DISTRHO_OS_WINDOWS
+ EnterCriticalSection(&fSection);
+#else
+ pthread_mutex_lock(&fMutex);
+#endif
+ }
+
+ /*
+ * Try to lock the mutex.
+ * Returns true if successful.
+ */
+ bool tryLock() const noexcept
+ {
+#ifdef DISTRHO_OS_WINDOWS
+ return (TryEnterCriticalSection(&fSection) != FALSE);
+#else
+ return (pthread_mutex_trylock(&fMutex) == 0);
+#endif
+ }
+
+ /*
+ * Unlock the mutex.
+ */
+ void unlock() const noexcept
+ {
+#ifdef DISTRHO_OS_WINDOWS
+ LeaveCriticalSection(&fSection);
+#else
+ pthread_mutex_unlock(&fMutex);
+#endif
+ }
+
+private:
+#ifdef DISTRHO_OS_WINDOWS
+ mutable CRITICAL_SECTION fSection;
+#else
+ mutable pthread_mutex_t fMutex;
+#endif
+
+ DISTRHO_PREVENT_HEAP_ALLOCATION
+ DISTRHO_DECLARE_NON_COPY_CLASS(RecursiveMutex)
+};
+
+// -----------------------------------------------------------------------
+// Helper class to lock&unlock a mutex during a function scope.
+
+template <class Mutex>
+class ScopedLocker
+{
+public:
+ ScopedLocker(const Mutex& mutex) noexcept
+ : fMutex(mutex)
+ {
+ fMutex.lock();
+ }
+
+ ~ScopedLocker() noexcept
+ {
+ fMutex.unlock();
+ }
+
+private:
+ const Mutex& fMutex;
+
+ DISTRHO_PREVENT_HEAP_ALLOCATION
+ DISTRHO_DECLARE_NON_COPY_CLASS(ScopedLocker)
+};
+
+// -----------------------------------------------------------------------
+// Helper class to unlock&lock a mutex during a function scope.
+
+template <class Mutex>
+class ScopedUnlocker
+{
+public:
+ ScopedUnlocker(const Mutex& mutex) noexcept
+ : fMutex(mutex)
+ {
+ fMutex.unlock();
+ }
+
+ ~ScopedUnlocker() noexcept
+ {
+ fMutex.lock();
+ }
+
+private:
+ const Mutex& fMutex;
+
+ DISTRHO_PREVENT_HEAP_ALLOCATION
+ DISTRHO_DECLARE_NON_COPY_CLASS(ScopedUnlocker)
+};
+
+// -----------------------------------------------------------------------
+// Define types
+
+typedef ScopedLocker<Mutex> MutexLocker;
+typedef ScopedLocker<RecursiveMutex> RecursiveMutexLocker;
+
+typedef ScopedUnlocker<Mutex> MutexUnlocker;
+typedef ScopedUnlocker<RecursiveMutex> RecursiveMutexUnlocker;
+
+// -----------------------------------------------------------------------
+
+#endif // DISTRHO_MUTEX_HPP_INCLUDED