passenger 4.0.20 → 4.0.21

data/ext/boost/thread/locks.hpp

@@ -6,1822 +6,11 @@
 
 #ifndef BOOST_THREAD_LOCKS_HPP
 #define BOOST_THREAD_LOCKS_HPP
-#include <boost/thread/detail/config.hpp>
-#include <boost/thread/exceptions.hpp>
-#include <boost/thread/detail/move.hpp>
-#include <algorithm>
-#include <iterator>
-#include <boost/thread/thread_time.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/type_traits/is_class.hpp>
-#ifdef BOOST_THREAD_USES_CHRONO
-#include <boost/chrono/time_point.hpp>
-#include <boost/chrono/duration.hpp>
-#endif
-
-#include <boost/config/abi_prefix.hpp>
-
-namespace boost
-{
-    struct xtime;
-
-#if defined(BOOST_NO_SFINAE) ||                           \
-    BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) || \
-    BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
-#define BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
-#endif
-
-#ifndef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
-    namespace detail
-    {
-#define BOOST_DEFINE_HAS_MEMBER_CALLED(member_name)                     \
-        template<typename T, bool=boost::is_class<T>::value>            \
-        struct has_member_called_##member_name                          \
-        {                                                               \
-            BOOST_STATIC_CONSTANT(bool, value=false);                   \
-        };                                                              \
-                                                                        \
-        template<typename T>                                            \
-        struct has_member_called_##member_name<T,true>                  \
-        {                                                               \
-            typedef char true_type;                                     \
-            struct false_type                                           \
-            {                                                           \
-                true_type dummy[2];                                     \
-            };                                                          \
-                                                                        \
-            struct fallback { int member_name; };                       \
-            struct derived:                                             \
-                T, fallback                                             \
-            {                                                           \
-                derived();                                              \
-            };                                                          \
-                                                                        \
-            template<int fallback::*> struct tester;                    \
-                                                                        \
-            template<typename U>                                        \
-                static false_type has_member(tester<&U::member_name>*); \
-            template<typename U>                                        \
-                static true_type has_member(...);                       \
-                                                                        \
-            BOOST_STATIC_CONSTANT(                                      \
-                bool, value=sizeof(has_member<derived>(0))==sizeof(true_type)); \
-        }
-
-        BOOST_DEFINE_HAS_MEMBER_CALLED(lock);
-        BOOST_DEFINE_HAS_MEMBER_CALLED(unlock);
-        BOOST_DEFINE_HAS_MEMBER_CALLED(try_lock);
-
-        template<typename T,bool=has_member_called_lock<T>::value >
-        struct has_member_lock
-        {
-            BOOST_STATIC_CONSTANT(bool, value=false);
-        };
-
-        template<typename T>
-        struct has_member_lock<T,true>
-        {
-            typedef char true_type;
-            struct false_type
-            {
-                true_type dummy[2];
-            };
-
-            template<typename U,typename V>
-            static true_type has_member(V (U::*)());
-            template<typename U>
-            static false_type has_member(U);
-
-            BOOST_STATIC_CONSTANT(
-                bool,value=sizeof(has_member_lock<T>::has_member(&T::lock))==sizeof(true_type));
-        };
-
-        template<typename T,bool=has_member_called_unlock<T>::value >
-        struct has_member_unlock
-        {
-            BOOST_STATIC_CONSTANT(bool, value=false);
-        };
-
-        template<typename T>
-        struct has_member_unlock<T,true>
-        {
-            typedef char true_type;
-            struct false_type
-            {
-                true_type dummy[2];
-            };
-
-            template<typename U,typename V>
-            static true_type has_member(V (U::*)());
-            template<typename U>
-            static false_type has_member(U);
-
-            BOOST_STATIC_CONSTANT(
-                bool,value=sizeof(has_member_unlock<T>::has_member(&T::unlock))==sizeof(true_type));
-        };
-
-        template<typename T,bool=has_member_called_try_lock<T>::value >
-        struct has_member_try_lock
-        {
-            BOOST_STATIC_CONSTANT(bool, value=false);
-        };
-
-        template<typename T>
-        struct has_member_try_lock<T,true>
-        {
-            typedef char true_type;
-            struct false_type
-            {
-                true_type dummy[2];
-            };
-
-            template<typename U>
-            static true_type has_member(bool (U::*)());
-            template<typename U>
-            static false_type has_member(U);
-
-            BOOST_STATIC_CONSTANT(
-                bool,value=sizeof(has_member_try_lock<T>::has_member(&T::try_lock))==sizeof(true_type));
-        };
-
-    }
-
-
-    template<typename T>
-    struct is_mutex_type
-    {
-        BOOST_STATIC_CONSTANT(bool, value = detail::has_member_lock<T>::value &&
-                              detail::has_member_unlock<T>::value &&
-                              detail::has_member_try_lock<T>::value);
-
-    };
-#else
-    template<typename T>
-    struct is_mutex_type
-    {
-        BOOST_STATIC_CONSTANT(bool, value = false);
-    };
-#endif
-
-    struct defer_lock_t
-    {};
-    struct try_to_lock_t
-    {};
-    struct adopt_lock_t
-    {};
-
-    BOOST_CONSTEXPR_OR_CONST defer_lock_t defer_lock={};
-    BOOST_CONSTEXPR_OR_CONST try_to_lock_t try_to_lock={};
-    BOOST_CONSTEXPR_OR_CONST adopt_lock_t adopt_lock={};
-
-    template<typename Mutex>
-    class shared_lock;
-
-    template<typename Mutex>
-    class upgrade_lock;
-
-    template<typename Mutex>
-    class unique_lock;
-
-    namespace detail
-    {
-        template<typename Mutex>
-        class try_lock_wrapper;
-    }
-
-#ifdef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
-    template<typename T>
-    struct is_mutex_type<unique_lock<T> >
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-
-    template<typename T>
-    struct is_mutex_type<shared_lock<T> >
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-
-    template<typename T>
-    struct is_mutex_type<upgrade_lock<T> >
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-
-    template<typename T>
-    struct is_mutex_type<detail::try_lock_wrapper<T> >
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-
-    class mutex;
-    class timed_mutex;
-    class recursive_mutex;
-    class recursive_timed_mutex;
-    class shared_mutex;
-
-    template<>
-    struct is_mutex_type<mutex>
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-    template<>
-    struct is_mutex_type<timed_mutex>
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-    template<>
-    struct is_mutex_type<recursive_mutex>
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-    template<>
-    struct is_mutex_type<recursive_timed_mutex>
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-    template<>
-    struct is_mutex_type<shared_mutex>
-    {
-        BOOST_STATIC_CONSTANT(bool, value = true);
-    };
-
-#endif
-
-    template<typename Mutex>
-    class lock_guard
-    {
-    private:
-        Mutex& m;
-
-    public:
-        typedef Mutex mutex_type;
-        BOOST_THREAD_NO_COPYABLE(lock_guard)
-
-        explicit lock_guard(Mutex& m_):
-            m(m_)
-        {
-            m.lock();
-        }
-        lock_guard(Mutex& m_,adopt_lock_t):
-            m(m_)
-        {}
-        ~lock_guard()
-        {
-            m.unlock();
-        }
-    };
-
-    template<typename Mutex>
-    class unique_lock
-    {
-    private:
-        Mutex* m;
-        bool is_locked;
-
-    private:
-        explicit unique_lock(upgrade_lock<Mutex>&);
-        unique_lock& operator=(upgrade_lock<Mutex>& other);
-    public:
-        typedef Mutex mutex_type;
-        BOOST_THREAD_MOVABLE_ONLY(unique_lock)
-
-#if 0 // This should not be needed anymore. Use instead BOOST_THREAD_MAKE_RV_REF.
-#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
-        unique_lock(const volatile unique_lock&);
-#endif
-#endif
-        unique_lock() BOOST_NOEXCEPT :
-            m(0),is_locked(false)
-        {}
-
-        explicit unique_lock(Mutex& m_):
-            m(&m_),is_locked(false)
-        {
-            lock();
-        }
-        unique_lock(Mutex& m_,adopt_lock_t):
-            m(&m_),is_locked(true)
-        {}
-        unique_lock(Mutex& m_,defer_lock_t) BOOST_NOEXCEPT:
-            m(&m_),is_locked(false)
-        {}
-        unique_lock(Mutex& m_,try_to_lock_t):
-            m(&m_),is_locked(false)
-        {
-            try_lock();
-        }
-        template<typename TimeDuration>
-        unique_lock(Mutex& m_,TimeDuration const& target_time):
-            m(&m_),is_locked(false)
-        {
-            timed_lock(target_time);
-        }
-        unique_lock(Mutex& m_,system_time const& target_time):
-            m(&m_),is_locked(false)
-        {
-            timed_lock(target_time);
-        }
-
-#ifdef BOOST_THREAD_USES_CHRONO
-        template <class Clock, class Duration>
-        unique_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t)
-                : m(&mtx), is_locked(mtx.try_lock_until(t))
-        {
-        }
-        template <class Rep, class Period>
-        unique_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d)
-                : m(&mtx), is_locked(mtx.try_lock_for(d))
-        {
-        }
-#endif
-
-        unique_lock(BOOST_THREAD_RV_REF(unique_lock) other) BOOST_NOEXCEPT:
-            m(BOOST_THREAD_RV(other).m),is_locked(BOOST_THREAD_RV(other).is_locked)
-        {
-          BOOST_THREAD_RV(other).is_locked=false;
-          BOOST_THREAD_RV(other).m=0;
-        }
-        BOOST_THREAD_EXPLICIT_LOCK_CONVERSION unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other);
-
-#ifndef BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION
-        unique_lock& operator=(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other)  BOOST_NOEXCEPT
-        {
-            unique_lock temp(::boost::move(other));
-            swap(temp);
-            return *this;
-        }
-#endif
-
-        unique_lock& operator=(BOOST_THREAD_RV_REF(unique_lock) other)  BOOST_NOEXCEPT
-        {
-            unique_lock temp(::boost::move(other));
-            swap(temp);
-            return *this;
-        }
-#if 0 // This should not be needed anymore. Use instead BOOST_THREAD_MAKE_RV_REF.
-#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
-        unique_lock& operator=(unique_lock<Mutex> other)
-        {
-            swap(other);
-            return *this;
-        }
-#endif // BOOST_WORKAROUND
-#endif
-
-        // Conversion from upgrade locking
-        unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<mutex_type> BOOST_THREAD_RV_REF_END ul, try_to_lock_t)
-        : m(0),is_locked(false)
-        {
-            if (BOOST_THREAD_RV(ul).owns_lock()) {
-              if (BOOST_THREAD_RV(ul).mutex()->try_unlock_upgrade_and_lock())
-              {
-                  m = BOOST_THREAD_RV(ul).release();
-                  is_locked = true;
-              }
-            }
-            else
-            {
-              m = BOOST_THREAD_RV(ul).release();
-            }
-        }
-
-#ifdef BOOST_THREAD_USES_CHRONO
-        template <class Clock, class Duration>
-        unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<mutex_type> BOOST_THREAD_RV_REF_END ul,
-                    const chrono::time_point<Clock, Duration>& abs_time)
-        : m(0),is_locked(false)
-        {
-            if (BOOST_THREAD_RV(ul).owns_lock()) {
-              if (BOOST_THREAD_RV(ul).mutex()->try_unlock_upgrade_and_lock_until(abs_time))
-              {
-                  m = BOOST_THREAD_RV(ul).release();
-                  is_locked = true;
-              }
-            }
-            else
-            {
-              m = BOOST_THREAD_RV(ul).release();
-            }
-        }
-
-        template <class Rep, class Period>
-        unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<mutex_type> BOOST_THREAD_RV_REF_END ul,
-                    const chrono::duration<Rep, Period>& rel_time)
-        : m(0),is_locked(false)
-        {
-          if (BOOST_THREAD_RV(ul).owns_lock()) {
-            if (BOOST_THREAD_RV(ul).mutex()->try_unlock_upgrade_and_lock_for(rel_time))
-            {
-              m = BOOST_THREAD_RV(ul).release();
-              is_locked = true;
-            }
-          }
-          else
-          {
-            m = BOOST_THREAD_RV(ul).release();
-          }
-        }
-#endif
-
-#ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
-        // Conversion from shared locking
-        unique_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl, try_to_lock_t)
-        : m(0),is_locked(false)
-        {
-          if (BOOST_THREAD_RV(sl).owns_lock()) {
-            if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock())
-            {
-                m = BOOST_THREAD_RV(sl).release();
-                is_locked = true;
-            }
-          }
-          else
-          {
-            m = BOOST_THREAD_RV(sl).release();
-          }
-        }
-
-#ifdef BOOST_THREAD_USES_CHRONO
-        template <class Clock, class Duration>
-        unique_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl,
-                    const chrono::time_point<Clock, Duration>& abs_time)
-        : m(0),is_locked(false)
-        {
-            if (BOOST_THREAD_RV(sl).owns_lock()) {
-              if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock_until(abs_time))
-              {
-                  m = BOOST_THREAD_RV(sl).release();
-                  is_locked = true;
-              }
-            }
-            else
-            {
-              m = BOOST_THREAD_RV(sl).release();
-            }
-        }
-
-        template <class Rep, class Period>
-        unique_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl,
-                    const chrono::duration<Rep, Period>& rel_time)
-        : m(0),is_locked(false)
-        {
-              if (BOOST_THREAD_RV(sl).owns_lock()) {
-                if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock_for(rel_time))
-                {
-                    m = BOOST_THREAD_RV(sl).release();
-                    is_locked = true;
-                }
-              }
-              else
-              {
-                m = BOOST_THREAD_RV(sl).release();
-              }
-        }
-#endif // BOOST_THREAD_USES_CHRONO
-#endif // BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
-
-
-        void swap(unique_lock& other) BOOST_NOEXCEPT
-        {
-            std::swap(m,other.m);
-            std::swap(is_locked,other.is_locked);
-        }
-
-        ~unique_lock()
-        {
-            if(owns_lock())
-            {
-                m->unlock();
-            }
-        }
-        void lock()
-        {
-            if(m==0)
-            {
-                boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
-            }
-            if(owns_lock())
-            {
-                boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
-            }
-            m->lock();
-            is_locked=true;
-        }
-        bool try_lock()
-        {
-            if(m==0)
-            {
-                boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
-            }
-            if(owns_lock())
-            {
-                boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
-            }
-            is_locked=m->try_lock();
-            return is_locked;
-        }
-        template<typename TimeDuration>
-        bool timed_lock(TimeDuration const& relative_time)
-        {
-          if(m==0)
-          {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
-          }
-          if(owns_lock())
-          {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
-          }
-            is_locked=m->timed_lock(relative_time);
-            return is_locked;
-        }
-
-        bool timed_lock(::boost::system_time const& absolute_time)
-        {
-          if(m==0)
-          {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
-          }
-          if(owns_lock())
-          {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
-          }
-            is_locked=m->timed_lock(absolute_time);
-            return is_locked;
-        }
-        bool timed_lock(::boost::xtime const& absolute_time)
-        {
-          if(m==0)
-          {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
-          }
-          if(owns_lock())
-          {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
-          }
-            is_locked=m->timed_lock(absolute_time);
-            return is_locked;
-        }
-
-#ifdef BOOST_THREAD_USES_CHRONO
-
-        template <class Rep, class Period>
-        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
-        {
-          if(m==0)
-          {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
-          }
-          if(owns_lock())
-          {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
-          }
-          is_locked=m->try_lock_for(rel_time);
-          return is_locked;
-        }
-        template <class Clock, class Duration>
-        bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
-        {
-          if(m==0)
-          {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
-          }
-          if(owns_lock())
-          {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
-          }
-          is_locked=m->try_lock_until(abs_time);
-          return is_locked;
-        }
-#endif
-
-        void unlock()
-        {
-          if(m==0)
-          {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
-          }
-            if(!owns_lock())
-            {
-                boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock doesn't own the mutex"));
-            }
-            m->unlock();
-            is_locked=false;
-        }
-
-#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-        typedef void (unique_lock::*bool_type)();
-        operator bool_type() const BOOST_NOEXCEPT
-        {
-            return is_locked?&unique_lock::lock:0;
-        }
-        bool operator!() const BOOST_NOEXCEPT
-        {
-            return !owns_lock();
-        }
-#else
-        explicit operator bool() const BOOST_NOEXCEPT
-        {
-            return owns_lock();
-        }
-#endif
-        bool owns_lock() const BOOST_NOEXCEPT
-        {
-            return is_locked;
-        }
-
-        Mutex* mutex() const BOOST_NOEXCEPT
-        {
-            return m;
-        }
-
-        Mutex* release() BOOST_NOEXCEPT
-        {
-            Mutex* const res=m;
-            m=0;
-            is_locked=false;
-            return res;
-        }
-
-        friend class shared_lock<Mutex>;
-        friend class upgrade_lock<Mutex>;
-    };
-
-    template<typename Mutex>
-    void swap(unique_lock<Mutex>& lhs,unique_lock<Mutex>& rhs) BOOST_NOEXCEPT
-    {
-        lhs.swap(rhs);
-    }
-
-    BOOST_THREAD_DCL_MOVABLE_BEG(Mutex) unique_lock<Mutex> BOOST_THREAD_DCL_MOVABLE_END
-
-    template<typename Mutex>
-    class shared_lock
-    {
-    protected:
-        Mutex* m;
-        bool is_locked;
-
-    public:
-        typedef Mutex mutex_type;
-        BOOST_THREAD_MOVABLE_ONLY(shared_lock)
-
-        shared_lock() BOOST_NOEXCEPT:
-            m(0),is_locked(false)
-        {}
-
-        explicit shared_lock(Mutex& m_):
-            m(&m_),is_locked(false)
-        {
-            lock();
-        }
-        shared_lock(Mutex& m_,adopt_lock_t):
-            m(&m_),is_locked(true)
-        {}
-        shared_lock(Mutex& m_,defer_lock_t) BOOST_NOEXCEPT:
-            m(&m_),is_locked(false)
-        {}
-        shared_lock(Mutex& m_,try_to_lock_t):
-            m(&m_),is_locked(false)
-        {
-            try_lock();
-        }
-        shared_lock(Mutex& m_,system_time const& target_time):
-            m(&m_),is_locked(false)
-        {
-            timed_lock(target_time);
-        }
-
-#ifdef BOOST_THREAD_USES_CHRONO
-        template <class Clock, class Duration>
-        shared_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t)
-                : m(&mtx), is_locked(mtx.try_lock_shared_until(t))
-        {
-        }
-        template <class Rep, class Period>
-        shared_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d)
-                : m(&mtx), is_locked(mtx.try_lock_shared_for(d))
-        {
-        }
-#endif
-
-        shared_lock(BOOST_THREAD_RV_REF_BEG shared_lock<Mutex> BOOST_THREAD_RV_REF_END other) BOOST_NOEXCEPT:
-            m(BOOST_THREAD_RV(other).m),is_locked(BOOST_THREAD_RV(other).is_locked)
-        {
-            BOOST_THREAD_RV(other).is_locked=false;
-            BOOST_THREAD_RV(other).m=0;
-        }
-
-        BOOST_THREAD_EXPLICIT_LOCK_CONVERSION shared_lock(BOOST_THREAD_RV_REF_BEG unique_lock<Mutex> BOOST_THREAD_RV_REF_END other):
-            m(BOOST_THREAD_RV(other).m),is_locked(BOOST_THREAD_RV(other).is_locked)
-        {
-            if(is_locked)
-            {
-                m->unlock_and_lock_shared();
-            }
-            BOOST_THREAD_RV(other).is_locked=false;
-            BOOST_THREAD_RV(other).m=0;
-        }
-
-        BOOST_THREAD_EXPLICIT_LOCK_CONVERSION shared_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other):
-            m(BOOST_THREAD_RV(other).m),is_locked(BOOST_THREAD_RV(other).is_locked)
-        {
-            if(is_locked)
-            {
-                m->unlock_upgrade_and_lock_shared();
-            }
-            BOOST_THREAD_RV(other).is_locked=false;
-            BOOST_THREAD_RV(other).m=0;
-        }
-
-
-        shared_lock& operator=(BOOST_THREAD_RV_REF_BEG shared_lock<Mutex> BOOST_THREAD_RV_REF_END other) BOOST_NOEXCEPT
-        {
-            shared_lock temp(::boost::move(other));
-            swap(temp);
-            return *this;
-        }
-#ifndef BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION
-        shared_lock& operator=(BOOST_THREAD_RV_REF_BEG unique_lock<Mutex> BOOST_THREAD_RV_REF_END other)
-        {
-            shared_lock temp(::boost::move(other));
-            swap(temp);
-            return *this;
-        }
-
-        shared_lock& operator=(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other)
-        {
-            shared_lock temp(::boost::move(other));
-            swap(temp);
-            return *this;
-        }
-#endif
-
-        void swap(shared_lock& other) BOOST_NOEXCEPT
-        {
-            std::swap(m,other.m);
-            std::swap(is_locked,other.is_locked);
-        }
-
-        Mutex* mutex() const BOOST_NOEXCEPT
-        {
-            return m;
-        }
-
-        Mutex* release() BOOST_NOEXCEPT
-        {
-            Mutex* const res=m;
-            m=0;
-            is_locked=false;
-            return res;
-        }
-
-        ~shared_lock()
-        {
-            if(owns_lock())
-            {
-                m->unlock_shared();
-            }
-        }
-        void lock()
-        {
-            if(m==0)
-            {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
-            }
-            if(owns_lock())
-            {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
-            }
-            m->lock_shared();
-            is_locked=true;
-        }
-        bool try_lock()
-        {
-            if(m==0)
-            {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
-            }
-            if(owns_lock())
-            {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
-            }
-            is_locked=m->try_lock_shared();
-            return is_locked;
-        }
-        bool timed_lock(boost::system_time const& target_time)
-        {
-            if(m==0)
-            {
-                boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
-            }
-            if(owns_lock())
-            {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
-            }
-            is_locked=m->timed_lock_shared(target_time);
-            return is_locked;
-        }
-        template<typename Duration>
-        bool timed_lock(Duration const& target_time)
-        {
-            if(m==0)
-            {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
-            }
-            if(owns_lock())
-            {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
-            }
-            is_locked=m->timed_lock_shared(target_time);
-            return is_locked;
-        }
-#ifdef BOOST_THREAD_USES_CHRONO
-        template <class Rep, class Period>
-        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
-        {
-          if(m==0)
-          {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
-          }
-          if(owns_lock())
-          {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
-          }
-          is_locked=m->try_lock_shared_for(rel_time);
-          return is_locked;
-        }
-        template <class Clock, class Duration>
-        bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
-        {
-          if(m==0)
-          {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
-          }
-          if(owns_lock())
-          {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
-          }
-          is_locked=m->try_lock_shared_until(abs_time);
-          return is_locked;
-        }
-#endif
-        void unlock()
-        {
-            if(m==0)
-            {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
-            }
-            if(!owns_lock())
-            {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock doesn't own the mutex"));
-            }
-            m->unlock_shared();
-            is_locked=false;
-        }
-
-#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-        typedef void (shared_lock<Mutex>::*bool_type)();
-        operator bool_type() const BOOST_NOEXCEPT
-        {
-            return is_locked?&shared_lock::lock:0;
-        }
-        bool operator!() const BOOST_NOEXCEPT
-        {
-            return !owns_lock();
-        }
-#else
-        explicit operator bool() const BOOST_NOEXCEPT
-        {
-            return owns_lock();
-        }
-#endif
-        bool owns_lock() const BOOST_NOEXCEPT
-        {
-            return is_locked;
-        }
-
-    };
-
-    BOOST_THREAD_DCL_MOVABLE_BEG(Mutex) shared_lock<Mutex> BOOST_THREAD_DCL_MOVABLE_END
-
-    template<typename Mutex>
-    void swap(shared_lock<Mutex>& lhs,shared_lock<Mutex>& rhs) BOOST_NOEXCEPT
-    {
-        lhs.swap(rhs);
-    }
-
-    template<typename Mutex>
-    class upgrade_lock
-    {
-    protected:
-        Mutex* m;
-        bool is_locked;
-
-    public:
-        typedef Mutex mutex_type;
-        BOOST_THREAD_MOVABLE_ONLY(upgrade_lock)
-
-        upgrade_lock() BOOST_NOEXCEPT:
-            m(0),is_locked(false)
-        {}
-
-        explicit upgrade_lock(Mutex& m_):
-            m(&m_),is_locked(false)
-        {
-            lock();
-        }
-        upgrade_lock(Mutex& m_,adopt_lock_t):
-            m(&m_),is_locked(true)
-        {}
-        upgrade_lock(Mutex& m_,defer_lock_t) BOOST_NOEXCEPT:
-            m(&m_),is_locked(false)
-        {}
-        upgrade_lock(Mutex& m_,try_to_lock_t):
-            m(&m_),is_locked(false)
-        {
-            try_lock();
-        }
-
-#ifdef BOOST_THREAD_USES_CHRONO
-        template <class Clock, class Duration>
-        upgrade_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t)
-                : m(&mtx), is_locked(mtx.try_lock_upgrade_until(t))
-        {
-        }
-        template <class Rep, class Period>
-        upgrade_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d)
-                : m(&mtx), is_locked(mtx.try_lock_upgrade_for(d))
-        {
-        }
-#endif
-
-        upgrade_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other) BOOST_NOEXCEPT:
-            m(BOOST_THREAD_RV(other).m),is_locked(BOOST_THREAD_RV(other).is_locked)
-        {
-            BOOST_THREAD_RV(other).is_locked=false;
-            BOOST_THREAD_RV(other).m=0;
-        }
-
-        BOOST_THREAD_EXPLICIT_LOCK_CONVERSION upgrade_lock(BOOST_THREAD_RV_REF_BEG unique_lock<Mutex> BOOST_THREAD_RV_REF_END other):
-            m(BOOST_THREAD_RV(other).m),is_locked(BOOST_THREAD_RV(other).is_locked)
-        {
-            if(is_locked)
-            {
-                m->unlock_and_lock_upgrade();
-            }
-            BOOST_THREAD_RV(other).is_locked=false;
-            BOOST_THREAD_RV(other).m=0;
-        }
-
-        upgrade_lock& operator=(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other) BOOST_NOEXCEPT
-        {
-            upgrade_lock temp(::boost::move(other));
-            swap(temp);
-            return *this;
-        }
-
-#ifndef BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION
-        upgrade_lock& operator=(BOOST_THREAD_RV_REF_BEG unique_lock<Mutex> BOOST_THREAD_RV_REF_END other)
-        {
-            upgrade_lock temp(::boost::move(other));
-            swap(temp);
-            return *this;
-        }
-#endif
-
-#ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
-        // Conversion from shared locking
-        upgrade_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl, try_to_lock_t)
-        : m(0),is_locked(false)
-        {
-          if (BOOST_THREAD_RV(sl).owns_lock()) {
-            if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock_upgrade())
-            {
-                m = BOOST_THREAD_RV(sl).release();
-                is_locked = true;
-            }
-          }
-          else
-          {
-            m = BOOST_THREAD_RV(sl).release();
-          }
-        }
-
-#ifdef BOOST_THREAD_USES_CHRONO
-        template <class Clock, class Duration>
-            upgrade_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl,
-                         const chrono::time_point<Clock, Duration>& abs_time)
-        : m(0),is_locked(false)
-        {
-          if (BOOST_THREAD_RV(sl).owns_lock()) {
-            if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock_upgrade_until(abs_time))
-            {
-                m = BOOST_THREAD_RV(sl).release();
-                is_locked = true;
-            }
-          }
-          else
-          {
-            m = BOOST_THREAD_RV(sl).release();
-          }
-        }
-
-        template <class Rep, class Period>
-            upgrade_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl,
-                         const chrono::duration<Rep, Period>& rel_time)
-        : m(0),is_locked(false)
-        {
-          if (BOOST_THREAD_RV(sl).owns_lock()) {
-            if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock_upgrade_for(rel_time))
-            {
-                m = BOOST_THREAD_RV(sl).release();
-                is_locked = true;
-            }
-          }
-          else
-          {
-            m = BOOST_THREAD_RV(sl).release();
-          }
-        }
-#endif // BOOST_THREAD_USES_CHRONO
-#endif // BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
-
-        void swap(upgrade_lock& other) BOOST_NOEXCEPT
-        {
-            std::swap(m,other.m);
-            std::swap(is_locked,other.is_locked);
-        }
-        Mutex* mutex() const BOOST_NOEXCEPT
-        {
-            return m;
-        }
-
-        Mutex* release() BOOST_NOEXCEPT
-        {
-            Mutex* const res=m;
-            m=0;
-            is_locked=false;
-            return res;
-        }
-        ~upgrade_lock()
-        {
-            if(owns_lock())
-            {
-                m->unlock_upgrade();
-            }
-        }
-        void lock()
-        {
-          if(m==0)
-          {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
-          }
-            if(owns_lock())
-            {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost upgrade_lock owns already the mutex"));
-            }
-            m->lock_upgrade();
-            is_locked=true;
-        }
-        bool try_lock()
-        {
-          if(m==0)
-          {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
-          }
-            if(owns_lock())
-            {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost upgrade_lock owns already the mutex"));
-            }
-            is_locked=m->try_lock_upgrade();
-            return is_locked;
-        }
-        void unlock()
-        {
-          if(m==0)
-          {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
-          }
-            if(!owns_lock())
-            {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost upgrade_lock doesn't own the mutex"));
-            }
-            m->unlock_upgrade();
-            is_locked=false;
-        }
-#ifdef BOOST_THREAD_USES_CHRONO
-        template <class Rep, class Period>
-        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
-        {
-          if(m==0)
-          {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
-          }
-          if(owns_lock())
-          {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
-          }
-          is_locked=m->try_lock_upgrade_for(rel_time);
-          return is_locked;
-        }
-        template <class Clock, class Duration>
-        bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
-        {
-          if(m==0)
-          {
-              boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
-          }
-          if(owns_lock())
-          {
-              boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
-          }
-          is_locked=m->try_lock_upgrade_until(abs_time);
-          return is_locked;
-        }
-#endif
-#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-        typedef void (upgrade_lock::*bool_type)();
-        operator bool_type() const BOOST_NOEXCEPT
-        {
-            return is_locked?&upgrade_lock::lock:0;
-        }
-        bool operator!() const BOOST_NOEXCEPT
-        {
-            return !owns_lock();
-        }
-#else
-        explicit operator bool() const BOOST_NOEXCEPT
-        {
-            return owns_lock();
-        }
-#endif
-        bool owns_lock() const BOOST_NOEXCEPT
-        {
-            return is_locked;
-        }
-        friend class shared_lock<Mutex>;
-        friend class unique_lock<Mutex>;
-    };
-
-    template<typename Mutex>
-    void swap(upgrade_lock<Mutex>& lhs,upgrade_lock<Mutex>& rhs) BOOST_NOEXCEPT
-    {
-        lhs.swap(rhs);
-    }
-
-    BOOST_THREAD_DCL_MOVABLE_BEG(Mutex) upgrade_lock<Mutex> BOOST_THREAD_DCL_MOVABLE_END
-
-    template<typename Mutex>
-    unique_lock<Mutex>::unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other):
-        m(BOOST_THREAD_RV(other).m),is_locked(BOOST_THREAD_RV(other).is_locked)
-    {
-        if(is_locked)
-        {
-            m->unlock_upgrade_and_lock();
-        }
-        BOOST_THREAD_RV(other).release();
-    }
-
-    template <class Mutex>
-    class upgrade_to_unique_lock
-    {
-    private:
-        upgrade_lock<Mutex>* source;
-        unique_lock<Mutex> exclusive;
-
-    public:
-        typedef Mutex mutex_type;
-        BOOST_THREAD_MOVABLE_ONLY(upgrade_to_unique_lock)
-
-        explicit upgrade_to_unique_lock(upgrade_lock<Mutex>& m_):
-            source(&m_),exclusive(::boost::move(*source))
-        {}
-        ~upgrade_to_unique_lock()
-        {
-            if(source)
-            {
-                *source=BOOST_THREAD_MAKE_RV_REF(upgrade_lock<Mutex>(::boost::move(exclusive)));
-            }
-        }
-
-        upgrade_to_unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_to_unique_lock<Mutex> BOOST_THREAD_RV_REF_END other) BOOST_NOEXCEPT:
-            source(BOOST_THREAD_RV(other).source),exclusive(::boost::move(BOOST_THREAD_RV(other).exclusive))
-        {
-            BOOST_THREAD_RV(other).source=0;
-        }
-
-        upgrade_to_unique_lock& operator=(BOOST_THREAD_RV_REF_BEG upgrade_to_unique_lock<Mutex> BOOST_THREAD_RV_REF_END other) BOOST_NOEXCEPT
-        {
-            upgrade_to_unique_lock temp(other);
-            swap(temp);
-            return *this;
-        }
-
-        void swap(upgrade_to_unique_lock& other) BOOST_NOEXCEPT
-        {
-            std::swap(source,other.source);
-            exclusive.swap(other.exclusive);
-        }
-
-#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-        typedef void (upgrade_to_unique_lock::*bool_type)(upgrade_to_unique_lock&);
-        operator bool_type() const BOOST_NOEXCEPT
-        {
-            return exclusive.owns_lock()?&upgrade_to_unique_lock::swap:0;
-        }
-        bool operator!() const BOOST_NOEXCEPT
-        {
-            return !owns_lock();
-        }
-#else
-        explicit operator bool() const BOOST_NOEXCEPT
-        {
-            return owns_lock();
-        }
-#endif
-
-        bool owns_lock() const BOOST_NOEXCEPT
-        {
-            return exclusive.owns_lock();
-        }
-    };
-
-    BOOST_THREAD_DCL_MOVABLE_BEG(Mutex) upgrade_to_unique_lock<Mutex> BOOST_THREAD_DCL_MOVABLE_END
-
-    namespace detail
-    {
-        template<typename Mutex>
-        class try_lock_wrapper:
-            private unique_lock<Mutex>
-        {
-            typedef unique_lock<Mutex> base;
-        public:
-            BOOST_THREAD_MOVABLE_ONLY(try_lock_wrapper)
-
-            try_lock_wrapper()
-            {}
-
-            explicit try_lock_wrapper(Mutex& m):
-                base(m,try_to_lock)
-            {}
-
-            try_lock_wrapper(Mutex& m_,adopt_lock_t):
-                base(m_,adopt_lock)
-            {}
-            try_lock_wrapper(Mutex& m_,defer_lock_t):
-                base(m_,defer_lock)
-            {}
-            try_lock_wrapper(Mutex& m_,try_to_lock_t):
-                base(m_,try_to_lock)
-            {}
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-            try_lock_wrapper(BOOST_THREAD_RV_REF(try_lock_wrapper) other):
-                base(::boost::move(other))
-            {}
-
-#elif defined BOOST_THREAD_USES_MOVE
-            try_lock_wrapper(BOOST_THREAD_RV_REF(try_lock_wrapper) other):
-                base(::boost::move(static_cast<base&>(other)))
-            {}
-
-#else
-            try_lock_wrapper(BOOST_THREAD_RV_REF(try_lock_wrapper) other):
-                base(BOOST_THREAD_RV_REF(base)(*other))
-            {}
-#endif
-            try_lock_wrapper& operator=(BOOST_THREAD_RV_REF_BEG try_lock_wrapper<Mutex> BOOST_THREAD_RV_REF_END other)
-            {
-                try_lock_wrapper temp(other);
-                swap(temp);
-                return *this;
-            }
-            void swap(try_lock_wrapper& other)
-            {
-                base::swap(other);
-            }
-            void lock()
-            {
-                base::lock();
-            }
-            bool try_lock()
-            {
-                return base::try_lock();
-            }
-            void unlock()
-            {
-                base::unlock();
-            }
-            bool owns_lock() const
-            {
-                return base::owns_lock();
-            }
-            Mutex* mutex() const
-            {
-                return base::mutex();
-            }
-            Mutex* release()
-            {
-                return base::release();
-            }
-
-#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-            typedef typename base::bool_type bool_type;
-            operator bool_type() const
-            {
-                return base::operator bool_type();
-            }
-            bool operator!() const
-            {
-                return !this->owns_lock();
-            }
-#else
-            explicit operator bool() const
-            {
-                return owns_lock();
-            }
-#endif
-        };
-
-        template<typename Mutex>
-        void swap(try_lock_wrapper<Mutex>& lhs,try_lock_wrapper<Mutex>& rhs)
-        {
-            lhs.swap(rhs);
-        }
-
-        template<typename MutexType1,typename MutexType2>
-        unsigned try_lock_internal(MutexType1& m1,MutexType2& m2)
-        {
-            boost::unique_lock<MutexType1> l1(m1,boost::try_to_lock);
-            if(!l1)
-            {
-                return 1;
-            }
-            if(!m2.try_lock())
-            {
-                return 2;
-            }
-            l1.release();
-            return 0;
-        }
-
-        template<typename MutexType1,typename MutexType2,typename MutexType3>
-        unsigned try_lock_internal(MutexType1& m1,MutexType2& m2,MutexType3& m3)
-        {
-            boost::unique_lock<MutexType1> l1(m1,boost::try_to_lock);
-            if(!l1)
-            {
-                return 1;
-            }
-            if(unsigned const failed_lock=try_lock_internal(m2,m3))
-            {
-                return failed_lock+1;
-            }
-            l1.release();
-            return 0;
-        }
-
-
-        template<typename MutexType1,typename MutexType2,typename MutexType3,
-                 typename MutexType4>
-        unsigned try_lock_internal(MutexType1& m1,MutexType2& m2,MutexType3& m3,
-                                   MutexType4& m4)
-        {
-            boost::unique_lock<MutexType1> l1(m1,boost::try_to_lock);
-            if(!l1)
-            {
-                return 1;
-            }
-            if(unsigned const failed_lock=try_lock_internal(m2,m3,m4))
-            {
-                return failed_lock+1;
-            }
-            l1.release();
-            return 0;
-        }
-
-        template<typename MutexType1,typename MutexType2,typename MutexType3,
-                 typename MutexType4,typename MutexType5>
-        unsigned try_lock_internal(MutexType1& m1,MutexType2& m2,MutexType3& m3,
-                                   MutexType4& m4,MutexType5& m5)
-        {
-            boost::unique_lock<MutexType1> l1(m1,boost::try_to_lock);
-            if(!l1)
-            {
-                return 1;
-            }
-            if(unsigned const failed_lock=try_lock_internal(m2,m3,m4,m5))
-            {
-                return failed_lock+1;
-            }
-            l1.release();
-            return 0;
-        }
-
-
-        template<typename MutexType1,typename MutexType2>
-        unsigned lock_helper(MutexType1& m1,MutexType2& m2)
-        {
-            boost::unique_lock<MutexType1> l1(m1);
-            if(!m2.try_lock())
-            {
-                return 1;
-            }
-            l1.release();
-            return 0;
-        }
-
-        template<typename MutexType1,typename MutexType2,typename MutexType3>
-        unsigned lock_helper(MutexType1& m1,MutexType2& m2,MutexType3& m3)
-        {
-            boost::unique_lock<MutexType1> l1(m1);
-            if(unsigned const failed_lock=try_lock_internal(m2,m3))
-            {
-                return failed_lock;
-            }
-            l1.release();
-            return 0;
-        }
-
-        template<typename MutexType1,typename MutexType2,typename MutexType3,
-                 typename MutexType4>
-        unsigned lock_helper(MutexType1& m1,MutexType2& m2,MutexType3& m3,
-                             MutexType4& m4)
-        {
-            boost::unique_lock<MutexType1> l1(m1);
-            if(unsigned const failed_lock=try_lock_internal(m2,m3,m4))
-            {
-                return failed_lock;
-            }
-            l1.release();
-            return 0;
-        }
-
-        template<typename MutexType1,typename MutexType2,typename MutexType3,
-                 typename MutexType4,typename MutexType5>
-        unsigned lock_helper(MutexType1& m1,MutexType2& m2,MutexType3& m3,
-                             MutexType4& m4,MutexType5& m5)
-        {
-            boost::unique_lock<MutexType1> l1(m1);
-            if(unsigned const failed_lock=try_lock_internal(m2,m3,m4,m5))
-            {
-                return failed_lock;
-            }
-            l1.release();
-            return 0;
-        }
-    }
-
-    namespace detail
-    {
-        template<bool x>
-        struct is_mutex_type_wrapper
-        {};
-
-        template<typename MutexType1,typename MutexType2>
-        void lock_impl(MutexType1& m1,MutexType2& m2,is_mutex_type_wrapper<true>)
-        {
-            unsigned const lock_count=2;
-            unsigned lock_first=0;
-            for(;;)
-            {
-                switch(lock_first)
-                {
-                case 0:
-                    lock_first=detail::lock_helper(m1,m2);
-                    if(!lock_first)
-                        return;
-                    break;
-                case 1:
-                    lock_first=detail::lock_helper(m2,m1);
-                    if(!lock_first)
-                        return;
-                    lock_first=(lock_first+1)%lock_count;
-                    break;
-                }
-            }
-        }
-
-        template<typename Iterator>
-        void lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>);
-    }
-
-
-    template<typename MutexType1,typename MutexType2>
-    void lock(MutexType1& m1,MutexType2& m2)
-    {
-        detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
-    }
-
-    template<typename MutexType1,typename MutexType2>
-    void lock(const MutexType1& m1,MutexType2& m2)
-    {
-        detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
-    }
-
-    template<typename MutexType1,typename MutexType2>
-    void lock(MutexType1& m1,const MutexType2& m2)
-    {
-        detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
-    }
-
-    template<typename MutexType1,typename MutexType2>
-    void lock(const MutexType1& m1,const MutexType2& m2)
-    {
-        detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
-    }
-
-    template<typename MutexType1,typename MutexType2,typename MutexType3>
-    void lock(MutexType1& m1,MutexType2& m2,MutexType3& m3)
-    {
-        unsigned const lock_count=3;
-        unsigned lock_first=0;
-        for(;;)
-        {
-            switch(lock_first)
-            {
-            case 0:
-                lock_first=detail::lock_helper(m1,m2,m3);
-                if(!lock_first)
-                    return;
-                break;
-            case 1:
-                lock_first=detail::lock_helper(m2,m3,m1);
-                if(!lock_first)
-                    return;
-                lock_first=(lock_first+1)%lock_count;
-                break;
-            case 2:
-                lock_first=detail::lock_helper(m3,m1,m2);
-                if(!lock_first)
-                    return;
-                lock_first=(lock_first+2)%lock_count;
-                break;
-            }
-        }
-    }
-
-    template<typename MutexType1,typename MutexType2,typename MutexType3,
-             typename MutexType4>
-    void lock(MutexType1& m1,MutexType2& m2,MutexType3& m3,
-              MutexType4& m4)
-    {
-        unsigned const lock_count=4;
-        unsigned lock_first=0;
-        for(;;)
-        {
-            switch(lock_first)
-            {
-            case 0:
-                lock_first=detail::lock_helper(m1,m2,m3,m4);
-                if(!lock_first)
-                    return;
-                break;
-            case 1:
-                lock_first=detail::lock_helper(m2,m3,m4,m1);
-                if(!lock_first)
-                    return;
-                lock_first=(lock_first+1)%lock_count;
-                break;
-            case 2:
-                lock_first=detail::lock_helper(m3,m4,m1,m2);
-                if(!lock_first)
-                    return;
-                lock_first=(lock_first+2)%lock_count;
-                break;
-            case 3:
-                lock_first=detail::lock_helper(m4,m1,m2,m3);
-                if(!lock_first)
-                    return;
-                lock_first=(lock_first+3)%lock_count;
-                break;
-            }
-        }
-    }
-
-    template<typename MutexType1,typename MutexType2,typename MutexType3,
-             typename MutexType4,typename MutexType5>
-    void lock(MutexType1& m1,MutexType2& m2,MutexType3& m3,
-              MutexType4& m4,MutexType5& m5)
-    {
-        unsigned const lock_count=5;
-        unsigned lock_first=0;
-        for(;;)
-        {
-            switch(lock_first)
-            {
-            case 0:
-                lock_first=detail::lock_helper(m1,m2,m3,m4,m5);
-                if(!lock_first)
-                    return;
-                break;
-            case 1:
-                lock_first=detail::lock_helper(m2,m3,m4,m5,m1);
-                if(!lock_first)
-                    return;
-                lock_first=(lock_first+1)%lock_count;
-                break;
-            case 2:
-                lock_first=detail::lock_helper(m3,m4,m5,m1,m2);
-                if(!lock_first)
-                    return;
-                lock_first=(lock_first+2)%lock_count;
-                break;
-            case 3:
-                lock_first=detail::lock_helper(m4,m5,m1,m2,m3);
-                if(!lock_first)
-                    return;
-                lock_first=(lock_first+3)%lock_count;
-                break;
-            case 4:
-                lock_first=detail::lock_helper(m5,m1,m2,m3,m4);
-                if(!lock_first)
-                    return;
-                lock_first=(lock_first+4)%lock_count;
-                break;
-            }
-        }
-    }
-
-    namespace detail
-    {
-        template<typename Mutex,bool x=is_mutex_type<Mutex>::value>
-        struct try_lock_impl_return
-        {
-            typedef int type;
-        };
-
-        template<typename Iterator>
-        struct try_lock_impl_return<Iterator,false>
-        {
-            typedef Iterator type;
-        };
-
-        template<typename MutexType1,typename MutexType2>
-        int try_lock_impl(MutexType1& m1,MutexType2& m2,is_mutex_type_wrapper<true>)
-        {
-            return ((int)detail::try_lock_internal(m1,m2))-1;
-        }
-
-        template<typename Iterator>
-        Iterator try_lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>);
-    }
-
-    template<typename MutexType1,typename MutexType2>
-    typename detail::try_lock_impl_return<MutexType1>::type try_lock(MutexType1& m1,MutexType2& m2)
-    {
-        return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
-    }
-
-    template<typename MutexType1,typename MutexType2>
-    typename detail::try_lock_impl_return<MutexType1>::type try_lock(const MutexType1& m1,MutexType2& m2)
-    {
-        return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
-    }
-
-    template<typename MutexType1,typename MutexType2>
-    typename detail::try_lock_impl_return<MutexType1>::type try_lock(MutexType1& m1,const MutexType2& m2)
-    {
-        return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
-    }
-
-    template<typename MutexType1,typename MutexType2>
-    typename detail::try_lock_impl_return<MutexType1>::type try_lock(const MutexType1& m1,const MutexType2& m2)
-    {
-        return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
-    }
-
-    template<typename MutexType1,typename MutexType2,typename MutexType3>
-    int try_lock(MutexType1& m1,MutexType2& m2,MutexType3& m3)
-    {
-        return ((int)detail::try_lock_internal(m1,m2,m3))-1;
-    }
-
-    template<typename MutexType1,typename MutexType2,typename MutexType3,typename MutexType4>
-    int try_lock(MutexType1& m1,MutexType2& m2,MutexType3& m3,MutexType4& m4)
-    {
-        return ((int)detail::try_lock_internal(m1,m2,m3,m4))-1;
-    }
-
-    template<typename MutexType1,typename MutexType2,typename MutexType3,typename MutexType4,typename MutexType5>
-    int try_lock(MutexType1& m1,MutexType2& m2,MutexType3& m3,MutexType4& m4,MutexType5& m5)
-    {
-        return ((int)detail::try_lock_internal(m1,m2,m3,m4,m5))-1;
-    }
-
-
-    namespace detail
-    {
-        template<typename Iterator>
-        struct range_lock_guard
-        {
-            Iterator begin;
-            Iterator end;
-
-            range_lock_guard(Iterator begin_,Iterator end_):
-                begin(begin_),end(end_)
-            {
-                boost::lock(begin,end);
-            }
-
-            void release()
-            {
-                begin=end;
-            }
-
-            ~range_lock_guard()
-            {
-                for(;begin!=end;++begin)
-                {
-                    begin->unlock();
-                }
-            }
-        };
-
-        template<typename Iterator>
-        Iterator try_lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>)
-
-        {
-            if(begin==end)
-            {
-                return end;
-            }
-            typedef typename std::iterator_traits<Iterator>::value_type lock_type;
-            unique_lock<lock_type> guard(*begin,try_to_lock);
-
-            if(!guard.owns_lock())
-            {
-                return begin;
-            }
-            Iterator const failed=boost::try_lock(++begin,end);
-            if(failed==end)
-            {
-                guard.release();
-            }
-
-            return failed;
-        }
-    }
-
-
-    namespace detail
-    {
-        template<typename Iterator>
-        void lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>)
-        {
-            typedef typename std::iterator_traits<Iterator>::value_type lock_type;
-
-            if(begin==end)
-            {
-                return;
-            }
-            bool start_with_begin=true;
-            Iterator second=begin;
-            ++second;
-            Iterator next=second;
-
-            for(;;)
-            {
-                unique_lock<lock_type> begin_lock(*begin,defer_lock);
-                if(start_with_begin)
-                {
-                    begin_lock.lock();
-                    Iterator const failed_lock=boost::try_lock(next,end);
-                    if(failed_lock==end)
-                    {
-                        begin_lock.release();
-                        return;
-                    }
-                    start_with_begin=false;
-                    next=failed_lock;
-                }
-                else
-                {
-                    detail::range_lock_guard<Iterator> guard(next,end);
-                    if(begin_lock.try_lock())
-                    {
-                        Iterator const failed_lock=boost::try_lock(second,next);
-                        if(failed_lock==next)
-                        {
-                            begin_lock.release();
-                            guard.release();
-                            return;
-                        }
-                        start_with_begin=false;
-                        next=failed_lock;
-                    }
-                    else
-                    {
-                        start_with_begin=true;
-                        next=second;
-                    }
-                }
-            }
-        }
-
-    }
 
-}
-#include <boost/config/abi_suffix.hpp>
+#include <boost/thread/lock_algorithms.hpp>
+#include <boost/thread/lock_types.hpp>
+#include <boost/thread/lock_guard.hpp>
+#include <boost/thread/lockable_traits.hpp>
+#include <boost/thread/lock_options.hpp>
 
 #endif