Subject: [Boost-commit] svn:boost r81081 - trunk/boost/thread
From: vicente.botet_at_[hidden]
Date: 2012-10-28 20:50:53
Author: viboes
Date: 2012-10-28 20:50:53 EDT (Sun, 28 Oct 2012)
New Revision: 81081
URL: http://svn.boost.org/trac/boost/changeset/81081
Log:
Thread: Added null_mutex
Added:
trunk/boost/thread/null_mutex.hpp (contents, props changed)
Added: trunk/boost/thread/null_mutex.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/thread/null_mutex.hpp 2012-10-28 20:50:53 EDT (Sun, 28 Oct 2012)
@@ -0,0 +1,240 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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/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 >*/
+
+ /// 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