1 files changed, 243 insertions, 0 deletions
diff --git a/boost/thread/null_mutex.hpp b/boost/thread/null_mutex.hpp
new file mode 100644
index 0000000000..f439f9ffb2
--- /dev/null
+++ b/boost/thread/null_mutex.hpp
@@ -0,0 +1,243 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008-2009,2012. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/thread for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_THREAD_NULL_MUTEX_HPP
+#define BOOST_THREAD_NULL_MUTEX_HPP
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/thread/detail/delete.hpp>
+#include <boost/chrono/chrono.hpp>
+
+/// \file
+/// Describes null_mutex class
+
+namespace boost
+{
+
+  /// Implements a mutex that simulates a mutex without doing any operation and
+  /// simulates a successful operation.
+  class null_mutex
+  {
+  public:
+
+    BOOST_THREAD_NO_COPYABLE( null_mutex) /*< no copyable >*/
+
+    null_mutex() {}
+
+    /// Simulates a mutex lock() operation. Empty function.
+    void lock()
+    {
+    }
+
+    /// Simulates a mutex try_lock() operation.
+    /// Equivalent to "return true;"
+    bool try_lock()
+    {
+      return true;
+    }
+
+    /// Simulates a mutex unlock() operation.
+    /// Empty function.
+    void unlock()
+    {
+    }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+    /// Simulates a mutex try_lock_until() operation.
+    /// Equivalent to "return true;"
+    template <typename Clock, typename Duration>
+    bool try_lock_until(chrono::time_point<Clock, Duration> const &)
+    {
+      return true;
+    }
+
+    /// Simulates a mutex try_lock_for() operation.
+    /// Equivalent to "return true;"
+    template <typename Rep, typename Period>
+    bool try_lock_for(chrono::duration<Rep, Period> const &)
+    {
+      return true;
+    }
+#endif
+
+    /// Simulates a mutex lock_shared() operation.
+    /// Empty function.
+    void lock_shared()
+    {
+    }
+
+    /// Simulates a mutex try_lock_shared() operation.
+    /// Equivalent to "return true;"
+    bool try_lock_shared()
+    {
+      return true;
+    }
+
+    /// Simulates a mutex unlock_shared() operation.
+    /// Empty function.
+    void unlock_shared()
+    {
+    }
+
+    /// Simulates a mutex try_lock_shared_until() operation.
+    /// Equivalent to "return true;"
+    template <typename Clock, typename Duration>
+    bool try_lock_shared_until(chrono::time_point<Clock, Duration> const &)
+    {
+      return true;
+    }
+    /// Simulates a mutex try_lock_shared_for() operation.
+    /// Equivalent to "return true;"
+    template <typename Rep, typename Period>
+    bool try_lock_shared_for(chrono::duration<Rep, Period> const &)
+    {
+      return true;
+    }
+
+    /// Simulates a mutex lock_upgrade() operation.
+    /// Empty function.
+    void lock_upgrade()
+    {
+    }
+
+    /// Simulates a mutex try_lock_upgrade() operation.
+    /// Equivalent to "return true;"
+    bool try_lock_upgrade()
+    {
+      return true;
+    }
+
+    /// Simulates a mutex unlock_upgrade() operation.
+    /// Empty function.
+    void unlock_upgrade()
+    {
+    }
+
+    /// Simulates a mutex try_lock_upgrade_until() operation.
+    /// Equivalent to "return true;"
+    template <typename Clock, typename Duration>
+    bool try_lock_upgrade_until(chrono::time_point<Clock, Duration> const &)
+    {
+      return true;
+    }
+
+    /// Simulates a mutex try_lock_upgrade_for() operation.
+    /// Equivalent to "return true;"
+    template <typename Rep, typename Period>
+    bool try_lock_upgrade_for(chrono::duration<Rep, Period> const &)
+    {
+      return true;
+    }
+
+    /// Simulates a mutex try_unlock_shared_and_lock() operation.
+    /// Equivalent to "return true;"
+    bool try_unlock_shared_and_lock()
+    {
+      return true;
+    }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+    /// Simulates a mutex try_unlock_shared_and_lock_until() operation.
+    /// Equivalent to "return true;"
+    template <typename Clock, typename Duration>
+    bool try_unlock_shared_and_lock_until(chrono::time_point<Clock, Duration> const &)
+    {
+      return true;
+    }
+
+    /// Simulates a mutex try_unlock_shared_and_lock_for() operation.
+    /// Equivalent to "return true;"
+    template <typename Rep, typename Period>
+    bool try_unlock_shared_and_lock_for(chrono::duration<Rep, Period> const &)
+    {
+      return true;
+    }
+#endif
+
+    /// Simulates unlock_and_lock_shared().
+    /// Empty function.
+    void unlock_and_lock_shared()
+    {
+    }
+
+    /// Simulates a mutex try_unlock_shared_and_lock_upgrade() operation.
+    /// Equivalent to "return true;"
+    bool try_unlock_shared_and_lock_upgrade()
+    {
+      return true;
+    }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+    /// Simulates a mutex try_unlock_shared_and_lock_upgrade_until() operation.
+    /// Equivalent to "return true;"
+    template <typename Clock, typename Duration>
+    bool try_unlock_shared_and_lock_upgrade_until(chrono::time_point<Clock, Duration> const &)
+    {
+      return true;
+    }
+
+    /// Simulates a mutex try_unlock_shared_and_lock_upgrade_for() operation.
+    /// Equivalent to "return true;"
+    template <typename Rep, typename Period>
+    bool try_unlock_shared_and_lock_upgrade_for(chrono::duration<Rep, Period> const &)
+    {
+      return true;
+    }
+#endif
+
+    /// Simulates unlock_and_lock_upgrade().
+    /// Empty function.
+    void unlock_and_lock_upgrade()
+    {
+    }
+
+    /// Simulates unlock_upgrade_and_lock().
+    /// Empty function.
+    void unlock_upgrade_and_lock()
+    {
+    }
+
+    /// Simulates a mutex try_unlock_upgrade_and_lock() operation.
+    /// Equivalent to "return true;"
+    bool try_unlock_upgrade_and_lock()
+    {
+      return true;
+    }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+    /// Simulates a mutex try_unlock_upgrade_and_lock_until() operation.
+    /// Equivalent to "return true;"
+    template <typename Clock, typename Duration>
+    bool try_unlock_upgrade_and_lock_until(chrono::time_point<Clock, Duration> const &)
+    {
+      return true;
+    }
+
+    /// Simulates a mutex try_unlock_upgrade_and_lock_for() operation.
+    /// Equivalent to "return true;"
+    template <typename Rep, typename Period>
+    bool try_unlock_upgrade_and_lock_for(chrono::duration<Rep, Period> const &)
+    {
+      return true;
+    }
+#endif
+
+    /// Simulates unlock_upgrade_and_lock_shared().
+    /// Empty function.
+    void unlock_upgrade_and_lock_shared()
+    {
+    }
+
+  };
+
+} //namespace boost {
+
+
+#endif