passenger 3.0.0 → 3.0.1

data/ext/boost/thread/detail/thread_group.hpp

@@ -18,10 +18,13 @@
 
 namespace boost
 {
-    class thread_group:
-        private noncopyable
+    class thread_group
     {
+    private:
+        thread_group(thread_group const&);
+        thread_group& operator=(thread_group const&);        
     public:
+        thread_group() {}
         ~thread_group()
         {
             for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();

data/ext/boost/thread/detail/tss_hooks.hpp

@@ -12,27 +12,9 @@
 
 #if defined(BOOST_HAS_WINTHREADS)
 
-    typedef void (__cdecl *thread_exit_handler)(void);
-
-    extern "C" BOOST_THREAD_DECL int at_thread_exit(
-        thread_exit_handler exit_handler
-        );
-        //Add a function to the list of functions that will
-            //be called when a thread is about to exit.
-        //Currently only implemented for Win32, but should
-            //later be implemented for all platforms.
-        //Used by Win32 implementation of Boost.Threads
-            //tss to perform cleanup.
-        //Like the C runtime library atexit() function,
-            //which it mimics, at_thread_exit() returns
-            //zero if successful and a nonzero
-            //value if an error occurs.
-
-#endif //defined(BOOST_HAS_WINTHREADS)
-
-#if defined(BOOST_HAS_WINTHREADS)
-
-    extern "C" BOOST_THREAD_DECL void on_process_enter(void);
+namespace boost
+{
+    BOOST_THREAD_DECL void __cdecl on_process_enter(void);
         //Function to be called when the exe or dll
             //that uses Boost.Threads first starts
             //or is first loaded.
@@ -42,7 +24,7 @@
             //a method for doing so has been discovered.
         //May be omitted; may be called multiple times.
 
-    extern "C" BOOST_THREAD_DECL void on_process_exit(void);
+    BOOST_THREAD_DECL void __cdecl on_process_exit(void);
         //Function to be called when the exe or dll
             //that uses Boost.Threads first starts
             //or is first loaded.
@@ -52,7 +34,7 @@
             //a method for doing so has been discovered.
         //Must not be omitted; may be called multiple times.
 
-    extern "C" BOOST_THREAD_DECL void on_thread_enter(void);
+    BOOST_THREAD_DECL void __cdecl on_thread_enter(void);
         //Function to be called just after a thread starts
             //in an exe or dll that uses Boost.Threads.
         //Must be called in the context of the thread
@@ -61,7 +43,7 @@
             //a method for doing so has been discovered.
         //May be omitted; may be called multiple times.
 
-    extern "C" BOOST_THREAD_DECL void __cdecl on_thread_exit(void);
+    BOOST_THREAD_DECL void __cdecl on_thread_exit(void);
         //Function to be called just be fore a thread ends
             //in an exe or dll that uses Boost.Threads.
         //Must be called in the context of the thread
@@ -70,10 +52,11 @@
             //a method for doing so has been discovered.
         //Must not be omitted; may be called multiple times.
     
-    extern "C" void tss_cleanup_implemented(void);
+    void tss_cleanup_implemented();
         //Dummy function used both to detect whether tss cleanup
             //cleanup has been implemented and to force
             //it to be linked into the Boost.Threads library.
+}
 
 #endif //defined(BOOST_HAS_WINTHREADS)
 

data/ext/boost/thread/future.hpp

@@ -1,4 +1,4 @@
-//  (C) Copyright 2008-9 Anthony Williams 
+//  (C) Copyright 2008-10 Anthony Williams 
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -9,6 +9,8 @@
 #include <stdexcept>
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/thread_time.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition_variable.hpp>
 #include <boost/exception_ptr.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/scoped_ptr.hpp>
@@ -16,6 +18,7 @@
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/config.hpp>
+#include <boost/throw_exception.hpp>
 #include <algorithm>
 #include <boost/function.hpp>
 #include <boost/bind.hpp>
@@ -139,6 +142,8 @@ namespace boost
                 {
                     lock.lock();
                 }
+            private:
+                relocker& operator=(relocker const&);
             };
 
             void do_callback(boost::unique_lock<boost::mutex>& lock)
@@ -218,7 +223,7 @@ namespace boost
         struct future_traits
         {
             typedef boost::scoped_ptr<T> storage_type;
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
             typedef T const& source_reference_type;
             struct dummy;
             typedef typename boost::mpl::if_<boost::is_fundamental<T>,dummy&,T&&>::type rvalue_source_type;
@@ -323,7 +328,7 @@ namespace boost
             move_dest_type get()
             {
                 wait();
-                return *result;
+                return static_cast<move_dest_type>(*result);
             }
 
             future_state::state get_state()
@@ -387,15 +392,18 @@ namespace boost
 
         class future_waiter
         {
+            struct registered_waiter;
+            typedef std::vector<registered_waiter>::size_type count_type;
+            
             struct registered_waiter
             {
                 boost::shared_ptr<detail::future_object_base> future;
                 detail::future_object_base::waiter_list::iterator wait_iterator;
-                unsigned index;
+                count_type index;
 
                 registered_waiter(boost::shared_ptr<detail::future_object_base> const& future_,
                                   detail::future_object_base::waiter_list::iterator wait_iterator_,
-                                  unsigned index_):
+                                  count_type index_):
                     future(future_),wait_iterator(wait_iterator_),index(index_)
                 {}
 
@@ -403,13 +411,13 @@ namespace boost
             
             struct all_futures_lock
             {
-                unsigned count;
+                count_type count;
                 boost::scoped_array<boost::unique_lock<boost::mutex> > locks;
                 
                 all_futures_lock(std::vector<registered_waiter>& futures):
                     count(futures.size()),locks(new boost::unique_lock<boost::mutex>[count])
                 {
-                    for(unsigned i=0;i<count;++i)
+                    for(count_type i=0;i<count;++i)
                     {
                         locks[i]=boost::unique_lock<boost::mutex>(futures[i].future->mutex);
                     }
@@ -422,7 +430,7 @@ namespace boost
                 
                 void unlock()
                 {
-                    for(unsigned i=0;i<count;++i)
+                    for(count_type i=0;i<count;++i)
                     {
                         locks[i].unlock();
                     }
@@ -431,7 +439,7 @@ namespace boost
             
             boost::condition_variable_any cv;
             std::vector<registered_waiter> futures;
-            unsigned future_count;
+            count_type future_count;
             
         public:
             future_waiter():
@@ -448,12 +456,12 @@ namespace boost
                 ++future_count;
             }
 
-            unsigned wait()
+            count_type wait()
             {
                 all_futures_lock lk(futures);
                 for(;;)
                 {
-                    for(unsigned i=0;i<futures.size();++i)
+                    for(count_type i=0;i<futures.size();++i)
                     {
                         if(futures[i].future->done)
                         {
@@ -466,7 +474,7 @@ namespace boost
             
             ~future_waiter()
             {
-                for(unsigned i=0;i<futures.size();++i)
+                for(count_type i=0;i<futures.size();++i)
                 {
                     futures[i].future->remove_external_waiter(futures[i].wait_iterator);
                 }
@@ -546,6 +554,9 @@ namespace boost
     template<typename Iterator>
     typename boost::disable_if<is_future_type<Iterator>,Iterator>::type wait_for_any(Iterator begin,Iterator end)
     {
+        if(begin==end)
+            return end;
+        
         detail::future_waiter waiter;
         for(Iterator current=begin;current!=end;++current)
         {
@@ -632,7 +643,7 @@ namespace boost
         ~unique_future()
         {}
 
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
         unique_future(unique_future && other)
         {
             future.swap(other.future);
@@ -673,7 +684,7 @@ namespace boost
         {
             if(!future)
             {
-                throw future_uninitialized();
+                boost::throw_exception(future_uninitialized());
             }
 
             return future->get();
@@ -709,7 +720,7 @@ namespace boost
         {
             if(!future)
             {
-                throw future_uninitialized();
+                boost::throw_exception(future_uninitialized());
             }
             future->wait(false);
         }
@@ -724,7 +735,7 @@ namespace boost
         {
             if(!future)
             {
-                throw future_uninitialized();
+                boost::throw_exception(future_uninitialized());
             }
             return future->timed_wait_until(abs_time);
         }
@@ -767,7 +778,7 @@ namespace boost
             future=other.future;
             return *this;
         }
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
         shared_future(shared_future && other)
         {
             future.swap(other.future);
@@ -830,7 +841,7 @@ namespace boost
         {
             if(!future)
             {
-                throw future_uninitialized();
+                boost::throw_exception(future_uninitialized());
             }
 
             return future->get();
@@ -866,7 +877,7 @@ namespace boost
         {
             if(!future)
             {
-                throw future_uninitialized();
+                boost::throw_exception(future_uninitialized());
             }
             future->wait(false);
         }
@@ -881,7 +892,7 @@ namespace boost
         {
             if(!future)
             {
-                throw future_uninitialized();
+                boost::throw_exception(future_uninitialized());
             }
             return future->timed_wait_until(abs_time);
         }
@@ -929,7 +940,7 @@ namespace boost
         }
 
         // Assignment
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
         promise(promise && rhs):
             future_obtained(rhs.future_obtained)
         {
@@ -974,7 +985,7 @@ namespace boost
             lazy_init();
             if(future_obtained)
             {
-                throw future_already_retrieved();
+                boost::throw_exception(future_already_retrieved());
             }
             future_obtained=true;
             return unique_future<R>(future);
@@ -986,7 +997,7 @@ namespace boost
             boost::lock_guard<boost::mutex> lock(future->mutex);
             if(future->done)
             {
-                throw promise_already_satisfied();
+                boost::throw_exception(promise_already_satisfied());
             }
             future->mark_finished_with_result_internal(r);
         }
@@ -998,7 +1009,7 @@ namespace boost
             boost::lock_guard<boost::mutex> lock(future->mutex);
             if(future->done)
             {
-                throw promise_already_satisfied();
+                boost::throw_exception(promise_already_satisfied());
             }
             future->mark_finished_with_result_internal(static_cast<typename detail::future_traits<R>::rvalue_source_type>(r));
         }
@@ -1009,7 +1020,7 @@ namespace boost
             boost::lock_guard<boost::mutex> lock(future->mutex);
             if(future->done)
             {
-                throw promise_already_satisfied();
+                boost::throw_exception(promise_already_satisfied());
             }
             future->mark_exceptional_finish_internal(p);
         }
@@ -1063,7 +1074,7 @@ namespace boost
         }
 
         // Assignment
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
         promise(promise && rhs):
             future_obtained(rhs.future_obtained)
         {
@@ -1109,7 +1120,7 @@ namespace boost
             
             if(future_obtained)
             {
-                throw future_already_retrieved();
+                boost::throw_exception(future_already_retrieved());
             }
             future_obtained=true;
             return unique_future<void>(future);
@@ -1121,7 +1132,7 @@ namespace boost
             boost::lock_guard<boost::mutex> lock(future->mutex);
             if(future->done)
             {
-                throw promise_already_satisfied();
+                boost::throw_exception(promise_already_satisfied());
             }
             future->mark_finished_with_result_internal();
         }
@@ -1132,7 +1143,7 @@ namespace boost
             boost::lock_guard<boost::mutex> lock(future->mutex);
             if(future->done)
             {
-                throw promise_already_satisfied();
+                boost::throw_exception(promise_already_satisfied());
             }
             future->mark_exceptional_finish_internal(p);
         }
@@ -1164,7 +1175,7 @@ namespace boost
                     boost::lock_guard<boost::mutex> lk(this->mutex);
                     if(started)
                     {
-                        throw task_already_started();
+                        boost::throw_exception(task_already_started());
                     }
                     started=true;
                 }
@@ -1283,7 +1294,7 @@ namespace boost
         }
 
         // assignment
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
         packaged_task(packaged_task&& other):
             future_obtained(other.future_obtained)
         {
@@ -1326,7 +1337,7 @@ namespace boost
         {
             if(!task)
             {
-                throw task_moved();
+                boost::throw_exception(task_moved());
             }
             else if(!future_obtained)
             {
@@ -1335,7 +1346,7 @@ namespace boost
             }
             else
             {
-                throw future_already_retrieved();
+                boost::throw_exception(future_already_retrieved());
             }
         }
         
@@ -1345,7 +1356,7 @@ namespace boost
         {
             if(!task)
             {
-                throw task_moved();
+                boost::throw_exception(task_moved());
             }
             task->run();
         }

data/ext/boost/thread/locks.hpp

@@ -11,6 +11,7 @@
 #include <iterator>
 #include <boost/thread/thread_time.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/type_traits/is_class.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -27,8 +28,52 @@ namespace boost
 #ifndef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
     namespace detail
     {
-        template<typename T>
+#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
@@ -36,15 +81,23 @@ namespace boost
                 true_type dummy[2];
             };
             
+            template<typename U,typename V>
+            static true_type has_member(V (U::*)());
             template<typename U>
-            static true_type has_member(U*,void (U::*dummy)()=&U::lock);
-            static false_type has_member(void*);
+            static false_type has_member(U);
             
-            BOOST_STATIC_CONSTANT(bool, value=sizeof(has_member_lock<T>::has_member((T*)NULL))==sizeof(true_type));
+            BOOST_STATIC_CONSTANT(
+                bool,value=sizeof(has_member_lock<T>::has_member(&T::lock))==sizeof(true_type));
         };
-
-        template<typename T>
+        
+        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
@@ -52,15 +105,23 @@ namespace boost
                 true_type dummy[2];
             };
             
+            template<typename U,typename V>
+            static true_type has_member(V (U::*)());
             template<typename U>
-            static true_type has_member(U*,void (U::*dummy)()=&U::unlock);
-            static false_type has_member(void*);
+            static false_type has_member(U);
             
-            BOOST_STATIC_CONSTANT(bool, value=sizeof(has_member_unlock<T>::has_member((T*)NULL))==sizeof(true_type));
+            BOOST_STATIC_CONSTANT(
+                bool,value=sizeof(has_member_unlock<T>::has_member(&T::unlock))==sizeof(true_type));
         };
         
-        template<typename T>
+        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
@@ -69,10 +130,12 @@ namespace boost
             };
             
             template<typename U>
-            static true_type has_member(U*,bool (U::*dummy)()=&U::try_lock);
-            static false_type has_member(void*);
+            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*)NULL))==sizeof(true_type));
+            BOOST_STATIC_CONSTANT(
+                bool,value=sizeof(has_member_try_lock<T>::has_member(&T::try_lock))==sizeof(true_type));
         };
 
     }
@@ -214,7 +277,7 @@ namespace boost
         unique_lock& operator=(unique_lock&);
         unique_lock& operator=(upgrade_lock<Mutex>& other);
     public:
-#ifdef __SUNPRO_CC 
+#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) 
         unique_lock(const volatile unique_lock&); 
 #endif
         unique_lock():
@@ -248,7 +311,7 @@ namespace boost
         {
             timed_lock(target_time);
         }
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
         unique_lock(unique_lock&& other):
             m(other.m),is_locked(other.is_locked)
         {
@@ -300,7 +363,7 @@ namespace boost
             return detail::thread_move_t<unique_lock<Mutex> >(*this);
         }
 
-#ifdef __SUNPRO_CC
+#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) 
         unique_lock& operator=(unique_lock<Mutex> other) 
         { 
             swap(other); 
@@ -321,17 +384,17 @@ namespace boost
             swap(temp);
             return *this;
         }
-        void swap(unique_lock& other)
-        {
-            std::swap(m,other.m);
-            std::swap(is_locked,other.is_locked);
-        }
         void swap(detail::thread_move_t<unique_lock<Mutex> > other)
         {
             std::swap(m,other->m);
             std::swap(is_locked,other->is_locked);
         }
 #endif
+        void swap(unique_lock& other)
+        {
+            std::swap(m,other.m);
+            std::swap(is_locked,other.is_locked);
+        }
         
         ~unique_lock()
         {
@@ -344,7 +407,7 @@ namespace boost
         {
             if(owns_lock())
             {
-                throw boost::lock_error();
+                boost::throw_exception(boost::lock_error());
             }
             m->lock();
             is_locked=true;
@@ -353,7 +416,7 @@ namespace boost
         {
             if(owns_lock())
             {
-                throw boost::lock_error();
+                boost::throw_exception(boost::lock_error());
             }
             is_locked=m->try_lock();
             return is_locked;
@@ -379,7 +442,7 @@ namespace boost
         {
             if(!owns_lock())
             {
-                throw boost::lock_error();
+                boost::throw_exception(boost::lock_error());
             }
             m->unlock();
             is_locked=false;
@@ -416,25 +479,42 @@ namespace boost
         friend class upgrade_lock<Mutex>;
     };
 
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
     template<typename Mutex>
     void swap(unique_lock<Mutex>&& lhs,unique_lock<Mutex>&& rhs)
     {
         lhs.swap(rhs);
     }
-#else
+
+    template<typename Mutex>
+    inline upgrade_lock<Mutex>&& move(upgrade_lock<Mutex>&& ul)
+    {
+        return static_cast<upgrade_lock<Mutex>&&>(ul);
+    }
+
+    template<typename Mutex>
+    inline upgrade_lock<Mutex>&& move(upgrade_lock<Mutex>& ul)
+    {
+        return static_cast<upgrade_lock<Mutex>&&>(ul);
+    }
+#endif
     template<typename Mutex>
     void swap(unique_lock<Mutex>& lhs,unique_lock<Mutex>& rhs)
     {
         lhs.swap(rhs);
     }
-#endif
 
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
     template<typename Mutex>
     inline unique_lock<Mutex>&& move(unique_lock<Mutex>&& ul)
     {
-        return ul;
+        return static_cast<unique_lock<Mutex>&&>(ul);
+    }
+
+    template<typename Mutex>
+    inline unique_lock<Mutex>&& move(unique_lock<Mutex>& ul)
+    {
+        return static_cast<unique_lock<Mutex>&&>(ul);
     }
 #endif
 
@@ -535,24 +615,24 @@ namespace boost
             return *this;
         }
 
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
         void swap(shared_lock&& other)
         {
             std::swap(m,other.m);
             std::swap(is_locked,other.is_locked);
         }
 #else
-        void swap(shared_lock& other)
-        {
-            std::swap(m,other.m);
-            std::swap(is_locked,other.is_locked);
-        }
         void swap(boost::detail::thread_move_t<shared_lock<Mutex> > other)
         {
             std::swap(m,other->m);
             std::swap(is_locked,other->is_locked);
         }
 #endif
+        void swap(shared_lock& other)
+        {
+            std::swap(m,other.m);
+            std::swap(is_locked,other.is_locked);
+        }
 
         Mutex* mutex() const
         {
@@ -570,7 +650,7 @@ namespace boost
         {
             if(owns_lock())
             {
-                throw boost::lock_error();
+                boost::throw_exception(boost::lock_error());
             }
             m->lock_shared();
             is_locked=true;
@@ -579,7 +659,7 @@ namespace boost
         {
             if(owns_lock())
             {
-                throw boost::lock_error();
+                boost::throw_exception(boost::lock_error());
             }
             is_locked=m->try_lock_shared();
             return is_locked;
@@ -588,7 +668,7 @@ namespace boost
         {
             if(owns_lock())
             {
-                throw boost::lock_error();
+                boost::throw_exception(boost::lock_error());
             }
             is_locked=m->timed_lock_shared(target_time);
             return is_locked;
@@ -598,7 +678,7 @@ namespace boost
         {
             if(owns_lock())
             {
-                throw boost::lock_error();
+                boost::throw_exception(boost::lock_error());
             }
             is_locked=m->timed_lock_shared(target_time);
             return is_locked;
@@ -607,7 +687,7 @@ namespace boost
         {
             if(!owns_lock())
             {
-                throw boost::lock_error();
+                boost::throw_exception(boost::lock_error());
             }
             m->unlock_shared();
             is_locked=false;
@@ -629,7 +709,7 @@ namespace boost
 
     };
 
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
     template<typename Mutex>
     void swap(shared_lock<Mutex>&& lhs,shared_lock<Mutex>&& rhs)
     {
@@ -673,6 +753,39 @@ namespace boost
         {
             try_lock();
         }
+#ifdef BOOST_HAS_RVALUE_REFS
+        upgrade_lock(upgrade_lock<Mutex>&& other):
+            m(other.m),is_locked(other.is_locked)
+        {
+            other.is_locked=false;
+            other.m=0;
+        }
+
+        upgrade_lock(unique_lock<Mutex>&& other):
+            m(other.m),is_locked(other.is_locked)
+        {
+            if(is_locked)
+            {
+                m->unlock_and_lock_upgrade();
+            }
+            other.is_locked=false;
+            other.m=0;
+        }
+
+        upgrade_lock& operator=(upgrade_lock<Mutex>&& other)
+        {
+            upgrade_lock temp(static_cast<upgrade_lock<Mutex>&&>(other));
+            swap(temp);
+            return *this;
+        }
+
+        upgrade_lock& operator=(unique_lock<Mutex>&& other)
+        {
+            upgrade_lock temp(static_cast<unique_lock<Mutex>&&>(other));
+            swap(temp);
+            return *this;
+        }
+#else
         upgrade_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):
             m(other->m),is_locked(other->is_locked)
         {
@@ -715,6 +828,7 @@ namespace boost
             swap(temp);
             return *this;
         }
+#endif
 
         void swap(upgrade_lock& other)
         {
@@ -733,7 +847,7 @@ namespace boost
         {
             if(owns_lock())
             {
-                throw boost::lock_error();
+                boost::throw_exception(boost::lock_error());
             }
             m->lock_upgrade();
             is_locked=true;
@@ -742,7 +856,7 @@ namespace boost
         {
             if(owns_lock())
             {
-                throw boost::lock_error();
+                boost::throw_exception(boost::lock_error());
             }
             is_locked=m->try_lock_upgrade();
             return is_locked;
@@ -751,7 +865,7 @@ namespace boost
         {
             if(!owns_lock())
             {
-                throw boost::lock_error();
+                boost::throw_exception(boost::lock_error());
             }
             m->unlock_upgrade();
             is_locked=false;
@@ -775,7 +889,7 @@ namespace boost
     };
 
 
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
     template<typename Mutex>
     unique_lock<Mutex>::unique_lock(upgrade_lock<Mutex>&& other):
         m(other.m),is_locked(other.is_locked)
@@ -819,6 +933,20 @@ namespace boost
             }
         }
 
+#ifdef BOOST_HAS_RVALUE_REFS
+        upgrade_to_unique_lock(upgrade_to_unique_lock<Mutex>&& other):
+            source(other.source),exclusive(move(other.exclusive))
+        {
+            other.source=0;
+        }
+        
+        upgrade_to_unique_lock& operator=(upgrade_to_unique_lock<Mutex>&& other)
+        {
+            upgrade_to_unique_lock temp(other);
+            swap(temp);
+            return *this;
+        }
+#else
         upgrade_to_unique_lock(detail::thread_move_t<upgrade_to_unique_lock<Mutex> > other):
             source(other->source),exclusive(move(other->exclusive))
         {
@@ -831,6 +959,7 @@ namespace boost
             swap(temp);
             return *this;
         }
+#endif
         void swap(upgrade_to_unique_lock& other)
         {
             std::swap(source,other.source);
@@ -875,7 +1004,7 @@ namespace boost
             try_lock_wrapper(Mutex& m_,try_to_lock_t):
                 base(m_,try_to_lock)
             {}
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
             try_lock_wrapper(try_lock_wrapper&& other):
                 base(other.move())
             {}
@@ -918,15 +1047,15 @@ namespace boost
                 return *this;
             }
 
-            void swap(try_lock_wrapper& other)
-            {
-                base::swap(other);
-            }
             void swap(detail::thread_move_t<try_lock_wrapper<Mutex> > other)
             {
                 base::swap(*other);
             }
 #endif
+            void swap(try_lock_wrapper& other)
+            {
+                base::swap(other);
+            }
             void lock()
             {
                 base::lock();
@@ -963,7 +1092,7 @@ namespace boost
             }
         };
 
-#ifdef BOOST_HAS_RVALUE_REFS
+#ifndef BOOST_NO_RVALUE_REFERENCES
         template<typename Mutex>
         void swap(try_lock_wrapper<Mutex>&& lhs,try_lock_wrapper<Mutex>&& rhs)
         {
@@ -1111,7 +1240,7 @@ namespace boost
         {
             unsigned const lock_count=2;
             unsigned lock_first=0;
-            while(true)
+            for(;;)
             {
                 switch(lock_first)
                 {
@@ -1164,7 +1293,7 @@ namespace boost
     {
         unsigned const lock_count=3;
         unsigned lock_first=0;
-        while(true)
+        for(;;)
         {
             switch(lock_first)
             {
@@ -1196,7 +1325,7 @@ namespace boost
     {
         unsigned const lock_count=4;
         unsigned lock_first=0;
-        while(true)
+        for(;;)
         {
             switch(lock_first)
             {
@@ -1234,7 +1363,7 @@ namespace boost
     {
         unsigned const lock_count=5;
         unsigned lock_first=0;
-        while(true)
+        for(;;)
         {
             switch(lock_first)
             {