1 files changed, 180 insertions, 0 deletions
diff --git a/ml/dlib/dlib/threads/auto_mutex_extension.h b/ml/dlib/dlib/threads/auto_mutex_extension.h
new file mode 100644
index 000000000..595c1b176
--- /dev/null
+++ b/ml/dlib/dlib/threads/auto_mutex_extension.h
@@ -0,0 +1,180 @@
+// Copyright (C) 2005  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_AUTO_MUTEX_EXTENSIOn_
+#define DLIB_AUTO_MUTEX_EXTENSIOn_
+
+#include "threads_kernel.h"
+#include "rmutex_extension.h"
+#include "read_write_mutex_extension.h"
+#include "auto_mutex_extension_abstract.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    class auto_mutex
+    {
+        /*!
+            INITIAL VALUE
+                - if (m != 0) then
+                    - the mutex pointed to by m is locked
+                - if (r != 0) then
+                    - the mutex pointed to by r is locked
+                - if (rw != 0) then
+                    - the mutex pointed to by rw is locked
+                - exactly one of r, m, or rw is not 0.
+
+            CONVENTION
+                - if (m != 0) then
+                    - the mutex pointed to by m is locked
+                - if (r != 0) then
+                    - the mutex pointed to by r is locked
+                - if (rw != 0) then
+                    - the mutex pointed to by rw is locked
+                - exactly one of r, m, or rw is not 0.
+        !*/
+    public:
+
+        explicit auto_mutex (
+            const mutex& m_
+        ) : m(&m_),
+            r(0),
+            rw(0)
+        {
+            m->lock();
+        }
+
+        explicit auto_mutex (
+            const rmutex& r_
+        ) : m(0),
+            r(&r_),
+            rw(0)
+        {
+            r->lock();
+        }
+
+        explicit auto_mutex (
+            const read_write_mutex& rw_
+        ) : m(0),
+            r(0),
+            rw(&rw_)
+        {
+            rw->lock();
+        }
+
+        void unlock()
+        {
+            if (m != 0)
+            {
+                m->unlock();
+                m = 0;
+            }
+            else if (r != 0)
+            {
+                r->unlock();
+                r = 0;
+            }
+            else if (rw != 0)
+            {
+                rw->unlock();
+                rw = 0;
+            }
+        }
+
+        ~auto_mutex (
+        )
+        {
+            unlock();
+        }
+
+    private:
+
+        const mutex* m;
+        const rmutex* r;
+        const read_write_mutex* rw;
+
+        // restricted functions
+        auto_mutex(auto_mutex&);        // copy constructor
+        auto_mutex& operator=(auto_mutex&);    // assignment operator
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    class auto_mutex_readonly
+    {
+    public:
+
+        explicit auto_mutex_readonly (
+            const read_write_mutex& rw_
+        ) : rw(rw_), _has_write_lock(false), _has_read_lock(true)
+        {
+            rw.lock_readonly();
+        }
+
+        ~auto_mutex_readonly (
+        )
+        {
+            unlock();
+        }
+
+        void lock_readonly (
+        )
+        {
+            if (!_has_read_lock)
+            {
+                unlock();
+                rw.lock_readonly();
+                _has_read_lock = true;
+            }
+        }
+
+        void lock_write (
+        )
+        {
+            if (!_has_write_lock)
+            {
+                unlock();
+                rw.lock();
+                _has_write_lock = true;
+            }
+        }
+
+        void unlock (
+        )
+        {
+            if (_has_write_lock)
+            {
+                rw.unlock();
+                _has_write_lock = false;
+            }
+            else if (_has_read_lock)
+            {
+                rw.unlock_readonly();
+                _has_read_lock = false;
+            }
+        }
+
+        bool has_read_lock (
+        ) { return _has_read_lock; }
+
+        bool has_write_lock (
+        ) { return _has_write_lock; }
+
+    private:
+
+        const read_write_mutex& rw;
+        bool _has_write_lock;
+        bool _has_read_lock;
+
+        // restricted functions
+        auto_mutex_readonly(auto_mutex_readonly&);        // copy constructor
+        auto_mutex_readonly& operator=(auto_mutex_readonly&);    // assignment operator
+    };
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_AUTO_MUTEX_EXTENSIOn_
+