[Boost-commit] svn:boost r85805 - in trunk/boost/sync: . detail/mutexes locks

Subject: [Boost-commit] svn:boost r85805 - in trunk/boost/sync: . detail/mutexes locks
From: andrey.semashev_at_[hidden]
Date: 2013-09-20 14:43:32

Author: andysem
Date: 2013-09-20 14:43:32 EDT (Fri, 20 Sep 2013)
New Revision: 85805
URL: http://svn.boost.org/trac/boost/changeset/85805

Log:
Extracted other lock types to fix compilation in C++03 mode.

Added:
   trunk/boost/sync/locks/shared_lock.hpp   (contents, props changed)
   trunk/boost/sync/locks/upgrade_lock.hpp   (contents, props changed)
Text files modified: 
   trunk/boost/sync/detail/mutexes/timed_mutex_posix.hpp |     8                                         
   trunk/boost/sync/locks.hpp                            |     2                                         
   trunk/boost/sync/locks/shared_lock.hpp                |   275 +++++++++++++++++++++++++++++++++++++   
   trunk/boost/sync/locks/unique_lock.hpp                |    10 +                                       
   trunk/boost/sync/locks/upgrade_lock.hpp               |   295 ++++++++++++++++++++++++++++++++++++++++
   5 files changed, 584 insertions(+), 6 deletions(-)

Modified: trunk/boost/sync/detail/mutexes/timed_mutex_posix.hpp
==============================================================================
--- trunk/boost/sync/detail/mutexes/timed_mutex_posix.hpp	Fri Sep 20 13:40:42 2013	(r85804)
+++ trunk/boost/sync/detail/mutexes/timed_mutex_posix.hpp	2013-09-20 14:43:32 EDT (Fri, 20 Sep 2013)	(r85805)
@@ -196,7 +196,7 @@
     template< typename Time >
     typename enable_if_c< sync::detail::time_traits< Time >::is_specialized, bool >::type timed_lock(Time const& t)
     {
-        return timed_lock(sync::detail::time_traits< Time >::to_sync_unit(t));
+        return priv_timed_lock(sync::detail::time_traits< Time >::to_sync_unit(t));
     }
 
     native_handle_type native_handle() BOOST_NOEXCEPT
@@ -208,12 +208,12 @@
     BOOST_DELETED_FUNCTION(timed_mutex& operator= (timed_mutex const&))
 
 private:
-    bool timed_lock(sync::detail::duration dur)
+    bool priv_timed_lock(sync::detail::duration dur)
     {
-        return timed_lock(sync::detail::time_point::now() + dur);
+        return priv_timed_lock(sync::detail::time_point::now() + dur);
     }
 
-    bool timed_lock(sync::detail::time_point const& t)
+    bool priv_timed_lock(sync::detail::time_point const& t)
     {
 #if defined(BOOST_SYNC_DETAIL_PTHREAD_HAS_TIMEDLOCK)
 

Modified: trunk/boost/sync/locks.hpp
==============================================================================
--- trunk/boost/sync/locks.hpp	Fri Sep 20 13:40:42 2013	(r85804)
+++ trunk/boost/sync/locks.hpp	2013-09-20 14:43:32 EDT (Fri, 20 Sep 2013)	(r85805)
@@ -23,5 +23,7 @@
 #include <boost/sync/locks/lock_guard.hpp>
 #include <boost/sync/locks/shared_lock_guard.hpp>
 #include <boost/sync/locks/unique_lock.hpp>
+#include <boost/sync/locks/shared_lock.hpp>
+#include <boost/sync/locks/upgrade_lock.hpp>
 
 #endif // BOOST_SYNC_LOCKS_HPP_INCLUDED_

Added: trunk/boost/sync/locks/shared_lock.hpp
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/boost/sync/locks/shared_lock.hpp	2013-09-20 14:43:32 EDT (Fri, 20 Sep 2013)	(r85805)
@@ -0,0 +1,275 @@
+/*
+ * 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)
+ *
+ * (C) Copyright 2007 Anthony Williams
+ * (C) Copyright 2011-2012 Vicente J. Botet Escriba
+ * (C) Copyright 2013 Andrey Semashev
+ */
+/*!
+ * \file   locks/shared_lock.hpp
+ *
+ * \brief  This header defines a shared lock guard.
+ */
+
+#ifndef BOOST_SYNC_LOCKS_SHARED_LOCK_HPP_INCLUDED_
+#define BOOST_SYNC_LOCKS_SHARED_LOCK_HPP_INCLUDED_
+
+#include <cstddef>
+#include <boost/throw_exception.hpp>
+#include <boost/move/core.hpp>
+#include <boost/move/utility.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/utility/explicit_operator_bool.hpp>
+#include <boost/sync/detail/config.hpp>
+#include <boost/sync/detail/time_traits.hpp>
+#include <boost/sync/detail/system_error.hpp>
+#include <boost/sync/exceptions/lock_error.hpp>
+#include <boost/sync/locks/lock_options.hpp>
+#include <boost/sync/locks/shared_lock_fwd.hpp>
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#include <boost/sync/locks/unique_lock_fwd.hpp>
+#include <boost/sync/locks/upgrade_lock_fwd.hpp>
+#else
+// These locks need to be defined for Boost.Move emulation
+#include <boost/sync/locks/unique_lock.hpp>
+#include <boost/sync/locks/upgrade_lock.hpp>
+#endif
+
+#include <boost/sync/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+
+namespace sync {
+
+/*!
+ * \brief A shared lock scope guard
+ */
+template< typename Mutex >
+class shared_lock
+{
+public:
+    typedef Mutex mutex_type;
+
+private:
+    mutex_type* m_mutex;
+    bool m_is_locked;
+
+public:
+    BOOST_MOVABLE_BUT_NOT_COPYABLE(shared_lock)
+
+public:
+    shared_lock() BOOST_NOEXCEPT :
+        m_mutex(NULL), m_is_locked(false)
+    {
+    }
+
+    explicit shared_lock(mutex_type& m) :
+        m_mutex(&m), m_is_locked(false)
+    {
+        lock();
+    }
+    shared_lock(mutex_type& m, adopt_lock_t) BOOST_NOEXCEPT :
+        m_mutex(&m), m_is_locked(true)
+    {
+    }
+    shared_lock(mutex_type& m, defer_lock_t) BOOST_NOEXCEPT :
+        m_mutex(&m), m_is_locked(false)
+    {
+    }
+    shared_lock(mutex_type& m, try_to_lock_t) :
+        m_mutex(&m), m_is_locked(false)
+    {
+        try_lock();
+    }
+
+    template< typename Time >
+    shared_lock(typename enable_if_c< detail::time_traits< Time >::is_specialized, mutex_type& >::type m, Time const& t) :
+        m_mutex(&m), m_is_locked(false)
+    {
+        timed_lock(t);
+    }
+
+    shared_lock(BOOST_RV_REF(shared_lock) that) BOOST_NOEXCEPT :
+        m_mutex(that.m_mutex), m_is_locked(that.m_is_locked)
+    {
+        that.m_mutex = NULL;
+        that.m_is_locked = false;
+    }
+
+    // Conversion from unique locking
+    explicit shared_lock(BOOST_RV_REF(unique_lock< mutex_type >) that) :
+        m_mutex(that.m_mutex), m_is_locked(that.m_is_locked)
+    {
+        if (m_is_locked)
+            m_mutex->unlock_and_lock_shared();
+        that.release();
+    }
+
+    explicit shared_lock(BOOST_RV_REF(upgrade_lock< mutex_type >) that) :
+        m_mutex(that.m_mutex), m_is_locked(that.m_is_locked)
+    {
+        if (m_is_locked)
+            m_mutex->unlock_upgrade_and_lock_shared();
+        that.release();
+    }
+
+    ~shared_lock()
+    {
+        if (m_is_locked)
+            m_mutex->unlock_shared();
+    }
+
+    shared_lock& operator= (BOOST_RV_REF(shared_lock) that) BOOST_NOEXCEPT
+    {
+        swap((shared_lock&)that);
+        return *this;
+    }
+
+    shared_lock& operator= (BOOST_RV_REF(unique_lock< mutex_type >) that)
+    {
+        shared_lock temp(boost::move(that));
+        swap(temp);
+        return *this;
+    }
+
+    shared_lock& operator= (BOOST_RV_REF(upgrade_lock< mutex_type >) that)
+    {
+        shared_lock temp(boost::move(that));
+        swap(temp);
+        return *this;
+    }
+
+    void lock()
+    {
+        if (!m_mutex)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::operation_not_permitted, "boost shared_lock has no mutex"));
+
+        if (m_is_locked)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::resource_deadlock_would_occur, "boost shared_lock already owns the mutex"));
+
+        m_mutex->lock_shared();
+        m_is_locked = true;
+    }
+
+    bool try_lock()
+    {
+        if (!m_mutex)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::operation_not_permitted, "boost shared_lock has no mutex"));
+
+        if (m_is_locked)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::resource_deadlock_would_occur, "boost shared_lock already owns the mutex"));
+
+        m_is_locked = m_mutex->try_lock_shared();
+
+        return m_is_locked;
+    }
+
+    template< typename Time >
+    typename enable_if_c< detail::time_traits< Time >::is_specialized, bool >::type timed_lock(Time const& time)
+    {
+        if (!m_mutex)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::operation_not_permitted, "boost shared_lock has no mutex"));
+
+        if (m_is_locked)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::resource_deadlock_would_occur, "boost shared_lock already owns the mutex"));
+
+        m_is_locked = m_mutex->timed_lock_shared(time);
+
+        return m_is_locked;
+    }
+
+    template< typename Duration >
+    typename detail::enable_if_tag< Duration, detail::time_duration_tag, bool >::type try_lock_for(Duration const& rel_time)
+    {
+        if (!m_mutex)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::operation_not_permitted, "boost shared_lock has no mutex"));
+
+        if (m_is_locked)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::resource_deadlock_would_occur, "boost shared_lock already owns the mutex"));
+
+        m_is_locked = m_mutex->try_lock_shared_for(rel_time);
+
+        return m_is_locked;
+    }
+
+    template< typename TimePoint >
+    typename detail::enable_if_tag< TimePoint, detail::time_point_tag, bool >::type try_lock_until(TimePoint const& abs_time)
+    {
+        if (!m_mutex)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::operation_not_permitted, "boost shared_lock has no mutex"));
+
+        if (m_is_locked)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::resource_deadlock_would_occur, "boost shared_lock already owns the mutex"));
+
+        m_is_locked = m_mutex->try_lock_shared_until(abs_time);
+
+        return m_is_locked;
+    }
+
+    void unlock()
+    {
+        if (!m_mutex)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::operation_not_permitted, "boost shared_lock has no mutex"));
+
+        if (!m_is_locked)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::operation_not_permitted, "boost shared_lock doesn't own the mutex"));
+
+        m_mutex->unlock_shared();
+        m_is_locked = false;
+    }
+
+    BOOST_EXPLICIT_OPERATOR_BOOL()
+
+    bool operator! () const BOOST_NOEXCEPT
+    {
+        return !m_is_locked;
+    }
+
+    bool owns_lock() const BOOST_NOEXCEPT
+    {
+        return m_is_locked;
+    }
+
+    mutex_type* mutex() const BOOST_NOEXCEPT
+    {
+        return m_mutex;
+    }
+
+    mutex_type* release() BOOST_NOEXCEPT
+    {
+        mutex_type* const res = m_mutex;
+        m_mutex = NULL;
+        m_is_locked = false;
+        return res;
+    }
+
+    void swap(shared_lock& that) BOOST_NOEXCEPT
+    {
+        mutex_type* const p = m_mutex;
+        m_mutex = that.m_mutex;
+        that.m_mutex = p;
+        const bool f = m_is_locked;
+        m_is_locked = that.m_is_locked;
+        that.m_is_locked = f;
+    }
+};
+
+template< typename Mutex >
+inline void swap(shared_lock< Mutex >& lhs, shared_lock< Mutex >& rhs) BOOST_NOEXCEPT
+{
+    lhs.swap(rhs);
+}
+
+} // namespace sync
+
+} // namespace boost
+
+#include <boost/sync/detail/footer.hpp>
+
+#endif // BOOST_SYNC_LOCKS_SHARED_LOCK_HPP_INCLUDED_

Modified: trunk/boost/sync/locks/unique_lock.hpp
==============================================================================
--- trunk/boost/sync/locks/unique_lock.hpp	Fri Sep 20 13:40:42 2013	(r85804)
+++ trunk/boost/sync/locks/unique_lock.hpp	2013-09-20 14:43:32 EDT (Fri, 20 Sep 2013)	(r85805)
@@ -28,8 +28,14 @@
 #include <boost/sync/exceptions/lock_error.hpp>
 #include <boost/sync/locks/lock_options.hpp>
 #include <boost/sync/locks/unique_lock_fwd.hpp>
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 #include <boost/sync/locks/shared_lock_fwd.hpp>
 #include <boost/sync/locks/upgrade_lock_fwd.hpp>
+#else
+// These locks need to be defined for Boost.Move emulation
+#include <boost/sync/locks/shared_lock.hpp>
+#include <boost/sync/locks/upgrade_lock.hpp>
+#endif
 
 #include <boost/sync/detail/header.hpp>
 
@@ -170,9 +176,9 @@
         return *this;
     }
 
-    unique_lock& operator= (BOOST_RV_REF(upgrade_lock< mutex_type >) other)
+    unique_lock& operator= (BOOST_RV_REF(upgrade_lock< mutex_type >) that)
     {
-        unique_lock temp(boost::move(other));
+        unique_lock temp(boost::move(that));
         swap(temp);
         return *this;
     }

Added: trunk/boost/sync/locks/upgrade_lock.hpp
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/boost/sync/locks/upgrade_lock.hpp	2013-09-20 14:43:32 EDT (Fri, 20 Sep 2013)	(r85805)
@@ -0,0 +1,295 @@
+/*
+ * 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)
+ *
+ * (C) Copyright 2007 Anthony Williams
+ * (C) Copyright 2011-2012 Vicente J. Botet Escriba
+ * (C) Copyright 2013 Andrey Semashev
+ */
+/*!
+ * \file   locks/upgrade_lock.hpp
+ *
+ * \brief  This header defines an upgradeable lock guard.
+ */
+
+#ifndef BOOST_SYNC_LOCKS_UPGRADE_LOCK_HPP_INCLUDED_
+#define BOOST_SYNC_LOCKS_UPGRADE_LOCK_HPP_INCLUDED_
+
+#include <cstddef>
+#include <boost/throw_exception.hpp>
+#include <boost/move/core.hpp>
+#include <boost/move/utility.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/utility/explicit_operator_bool.hpp>
+#include <boost/sync/detail/config.hpp>
+#include <boost/sync/detail/time_traits.hpp>
+#include <boost/sync/detail/system_error.hpp>
+#include <boost/sync/exceptions/lock_error.hpp>
+#include <boost/sync/locks/lock_options.hpp>
+#include <boost/sync/locks/upgrade_lock_fwd.hpp>
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#include <boost/sync/locks/unique_lock_fwd.hpp>
+#include <boost/sync/locks/shared_lock_fwd.hpp>
+#else
+// These locks need to be defined for Boost.Move emulation
+#include <boost/sync/locks/unique_lock.hpp>
+#include <boost/sync/locks/shared_lock.hpp>
+#endif
+
+#include <boost/sync/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+
+namespace sync {
+
+/*!
+ * \brief An upgradeable lock scope guard
+ */
+template< typename Mutex >
+class upgrade_lock
+{
+public:
+    typedef Mutex mutex_type;
+
+private:
+    mutex_type* m_mutex;
+    bool m_is_locked;
+
+public:
+    BOOST_MOVABLE_BUT_NOT_COPYABLE(upgrade_lock)
+
+public:
+    upgrade_lock() BOOST_NOEXCEPT :
+        m_mutex(NULL), m_is_locked(false)
+    {
+    }
+
+    explicit upgrade_lock(mutex_type& m) :
+        m_mutex(&m), m_is_locked(false)
+    {
+        lock();
+    }
+    upgrade_lock(mutex_type& m, adopt_lock_t) BOOST_NOEXCEPT :
+        m_mutex(&m), m_is_locked(true)
+    {
+    }
+    upgrade_lock(mutex_type& m, defer_lock_t) BOOST_NOEXCEPT :
+        m_mutex(&m), m_is_locked(false)
+    {
+    }
+    upgrade_lock(mutex_type& m, try_to_lock_t) :
+        m_mutex(&m), m_is_locked(false)
+    {
+        try_lock();
+    }
+
+    template< typename Time >
+    upgrade_lock(typename enable_if_c< detail::time_traits< Time >::is_specialized, mutex_type& >::type m, Time const& t) :
+        m_mutex(&m), m_is_locked(false)
+    {
+        timed_lock(t);
+    }
+
+    upgrade_lock(BOOST_RV_REF(upgrade_lock) that) BOOST_NOEXCEPT :
+        m_mutex(that.m_mutex), m_is_locked(that.m_is_locked)
+    {
+        that.m_mutex = NULL;
+        that.m_is_locked = false;
+    }
+
+    explicit upgrade_lock(BOOST_RV_REF(unique_lock< mutex_type >) that) :
+        m_mutex(that.m_mutex), m_is_locked(that.m_is_locked)
+    {
+        if (m_is_locked)
+            m_mutex->unlock_and_lock_upgrade();
+        that.release();
+    }
+
+    // Conversion from shared lock
+    upgrade_lock(BOOST_RV_REF(shared_lock< mutex_type >) sl, try_to_lock_t) :
+        m_mutex(NULL), m_is_locked(false)
+    {
+        if (sl.owns_lock())
+        {
+            if (sl.mutex()->try_unlock_shared_and_lock_upgrade())
+            {
+                m_mutex = sl.release();
+                m_is_locked = true;
+            }
+        }
+        else
+        {
+            m_mutex = sl.release();
+        }
+    }
+
+    template< typename Time >
+    upgrade_lock(BOOST_RV_REF(shared_lock< mutex_type >) sl, Time const& t, typename enable_if_c< detail::time_traits< Time >::is_specialized, int >::type = 0) :
+        m_mutex(NULL), m_is_locked(false)
+    {
+        if (sl.owns_lock())
+        {
+            if (sl.mutex()->timed_unlock_shared_and_lock_upgrade(t))
+            {
+                m_mutex = sl.release();
+                m_is_locked = true;
+            }
+        }
+        else
+        {
+            m_mutex = sl.release();
+        }
+    }
+
+    ~upgrade_lock()
+    {
+        if (m_is_locked)
+            m_mutex->unlock_upgrade();
+    }
+
+    upgrade_lock& operator= (BOOST_RV_REF(upgrade_lock) that) BOOST_NOEXCEPT
+    {
+        swap((upgrade_lock&)that);
+        return *this;
+    }
+
+    upgrade_lock& operator= (BOOST_RV_REF(unique_lock< mutex_type >) that)
+    {
+        upgrade_lock temp(boost::move(that));
+        swap(temp);
+        return *this;
+    }
+
+    void lock()
+    {
+        if (!m_mutex)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::operation_not_permitted, "boost upgrade_lock has no mutex"));
+
+        if (m_is_locked)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::resource_deadlock_would_occur, "boost upgrade_lock already owns the mutex"));
+
+        m_mutex->lock_upgrade();
+        m_is_locked = true;
+    }
+
+    bool try_lock()
+    {
+        if (!m_mutex)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::operation_not_permitted, "boost upgrade_lock has no mutex"));
+
+        if (m_is_locked)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::resource_deadlock_would_occur, "boost upgrade_lock already owns the mutex"));
+
+        m_is_locked = m_mutex->try_lock_upgrade();
+
+        return m_is_locked;
+    }
+
+    template< typename Time >
+    typename enable_if_c< detail::time_traits< Time >::is_specialized, bool >::type timed_lock(Time const& time)
+    {
+        if (!m_mutex)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::operation_not_permitted, "boost upgrade_lock has no mutex"));
+
+        if (m_is_locked)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::resource_deadlock_would_occur, "boost upgrade_lock already owns the mutex"));
+
+        m_is_locked = m_mutex->timed_lock_upgrade(time);
+
+        return m_is_locked;
+    }
+
+    template< typename Duration >
+    typename detail::enable_if_tag< Duration, detail::time_duration_tag, bool >::type try_lock_for(Duration const& rel_time)
+    {
+        if (!m_mutex)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::operation_not_permitted, "boost upgrade_lock has no mutex"));
+
+        if (m_is_locked)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::resource_deadlock_would_occur, "boost upgrade_lock already owns the mutex"));
+
+        m_is_locked = m_mutex->try_lock_upgrade_for(rel_time);
+
+        return m_is_locked;
+    }
+
+    template< typename TimePoint >
+    typename detail::enable_if_tag< TimePoint, detail::time_point_tag, bool >::type try_lock_until(TimePoint const& abs_time)
+    {
+        if (!m_mutex)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::operation_not_permitted, "boost upgrade_lock has no mutex"));
+
+        if (m_is_locked)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::resource_deadlock_would_occur, "boost upgrade_lock already owns the mutex"));
+
+        m_is_locked = m_mutex->try_lock_upgrade_until(abs_time);
+
+        return m_is_locked;
+    }
+
+    void unlock()
+    {
+        if (!m_mutex)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::operation_not_permitted, "boost upgrade_lock has no mutex"));
+
+        if (!m_is_locked)
+            BOOST_THROW_EXCEPTION(lock_error(detail::system_namespace::errc::operation_not_permitted, "boost upgrade_lock doesn't own the mutex"));
+
+        m_mutex->unlock_upgrade();
+        m_is_locked = false;
+    }
+
+    BOOST_EXPLICIT_OPERATOR_BOOL()
+
+    bool operator! () const BOOST_NOEXCEPT
+    {
+        return !m_is_locked;
+    }
+
+    bool owns_lock() const BOOST_NOEXCEPT
+    {
+        return m_is_locked;
+    }
+
+    mutex_type* mutex() const BOOST_NOEXCEPT
+    {
+        return m_mutex;
+    }
+
+    mutex_type* release() BOOST_NOEXCEPT
+    {
+        mutex_type* const res = m_mutex;
+        m_mutex = NULL;
+        m_is_locked = false;
+        return res;
+    }
+
+    void swap(upgrade_lock& that) BOOST_NOEXCEPT
+    {
+        mutex_type* const p = m_mutex;
+        m_mutex = that.m_mutex;
+        that.m_mutex = p;
+        const bool f = m_is_locked;
+        m_is_locked = that.m_is_locked;
+        that.m_is_locked = f;
+    }
+};
+
+template< typename Mutex >
+inline void swap(upgrade_lock< Mutex >& lhs, upgrade_lock< Mutex >& rhs) BOOST_NOEXCEPT
+{
+    lhs.swap(rhs);
+}
+
+} // namespace sync
+
+} // namespace boost
+
+#include <boost/sync/detail/footer.hpp>
+
+#endif // BOOST_SYNC_LOCKS_UPGRADE_LOCK_HPP_INCLUDED_