Ticket #6194: 6194_0.patch

boost/move/move.hpp

@@ -375 +375 @@
       {  return *static_cast< ::boost::rv<TYPE>* >(this);  }\
       operator const ::boost::rv<TYPE>&() const \
       {  return *static_cast<const ::boost::rv<TYPE>* >(this);  }\
+      ::boost::rv<TYPE>& move()\
+      {  return static_cast< ::boost::rv<TYPE>& >(*this);  }\
+      ::boost::rv<TYPE> const& copy() const\
+      {  return static_cast< ::boost::rv<TYPE> const& >(*this);  }\
       private:\
    //
 
@@ -393 +397 @@
       {  return *static_cast< ::boost::rv<TYPE>* >(this);  }\
       operator const ::boost::rv<TYPE>&() const \
       {  return *static_cast<const ::boost::rv<TYPE>* >(this);  }\
+      ::boost::rv<TYPE>& move()\
+      {  return static_cast< ::boost::rv<TYPE>& >(*this);  }\
+      ::boost::rv<TYPE> const& copy() const\
+      {  return static_cast< ::boost::rv<TYPE> const& >(*this);  }\
       private:\
    //
 
@@ -402 +410 @@
       {  return *static_cast< ::boost::rv<TYPE>* >(this);  }\
       operator const ::boost::rv<TYPE>&() const \
       {  return *static_cast<const ::boost::rv<TYPE>* >(this);  }\
+      ::boost::rv<TYPE>& move()\
+      {  return static_cast< ::boost::rv<TYPE>& >(*this);  }\
+      ::boost::rv<TYPE> const& copy() const\
+      {  return static_cast< ::boost::rv<TYPE> const& >(*this);  }\
       private:\
    //
 
@@ -518 +530 @@
    #define BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)\
       public:\
       typedef int boost_move_emulation_t;\
+      TYPE&& move()\
+      {  return static_cast< TYPE&& >(*this);  }\
+      TYPE const& copy() const\
+      {  return static_cast< TYPE const& >(*this);  }\
       private:\
       TYPE(const TYPE &);\
       TYPE& operator=(const TYPE &);\
@@ -527 +543 @@
    //! The user will need to write a move constructor/assignment and a copy assignment
    //! as explained in the documentation to fully write a copyable and movable class.
    #define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
+      public:\
+      TYPE&& move()\
+      {  return static_cast< TYPE&& >(*this);  }\
+      TYPE const& copy() const\
+      {  return static_cast< TYPE const& >(*this);  }\
+      private:\
    //
 
    #define BOOST_COPYABLE_AND_MOVABLE_ALT(TYPE)\
+      public:\
+      TYPE&& move()\
+      {  return static_cast< TYPE&& >(*this);  }\
+      TYPE const& copy() const\
+      {  return static_cast< TYPE const& >(*this);  }\
+      private:\
    //
 
    //!This macro is used to achieve portable syntax in move

boost/thread/detail/thread.hpp

@@ -9 +9 @@
 #ifndef BOOST_NO_IOSTREAM
 #include <ostream>
 #endif
-#include <boost/thread/detail/move.hpp>
+#include <boost/move/move.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/xtime.hpp>
 #include <boost/thread/detail/thread_heap_alloc.hpp>
@@ -23 +23 @@
 #include <stdlib.h>
 #include <memory>
 #include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_convertible.hpp>
 #include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/is_lvalue_reference.hpp>
+#include <boost/mpl/if.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -41 +44 @@
             public detail::thread_data_base
         {
         public:
-#ifndef BOOST_NO_RVALUE_REFERENCES
-            thread_data(F&& f_):
-                f(static_cast<F&&>(f_))
-            {}
-            thread_data(F& f_):
-                f(f_)
+            thread_data(BOOST_RV_REF(F) f_):
+                f(boost::move(f_))
             {}
-#else
-            thread_data(F f_):
+            thread_data(F const& f_):
                 f(f_)
             {}
-            thread_data(detail::thread_move_t<F> f_):
+            void run()
+            {
+                f();
+            }
+        private:
+            F f;
+
+            void operator=(thread_data&);
+            thread_data(thread_data&);
+        };
+        
+        template<typename R>
+        class thread_data<R()>:
+            public detail::thread_data_base
+        {
+        public:
+            thread_data(R f_()):
                 f(f_)
             {}
-#endif            
             void run()
             {
                 f();
             }
         private:
-            F f;
+            R (*f)();
 
             void operator=(thread_data&);
             thread_data(thread_data&);
@@ -110 +123 @@
     class BOOST_THREAD_DECL thread
     {
     private:
-        thread(thread&);
-        thread& operator=(thread&);
-
+        BOOST_MOVABLE_BUT_NOT_COPYABLE(thread)
         void release_handle();
         
         detail::thread_data_ptr thread_info;
@@ -123 +134 @@
 
         detail::thread_data_ptr get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const;
 
-#ifndef BOOST_NO_RVALUE_REFERENCES
         template<typename F>
-        static inline detail::thread_data_ptr make_thread_info(F&& f)
+        static inline detail::thread_data_ptr make_thread_info(BOOST_RV_REF(F) f)
         {
-            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<typename boost::remove_reference<F>::type> >(static_cast<F&&>(f)));
+            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<typename boost::remove_reference<F>::type> >(boost::move(f)));
         }
-        static inline detail::thread_data_ptr make_thread_info(void (*f)())
-        {
-            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<void(*)()> >(static_cast<void(*&&)()>(f)));
-        }
-#else
         template<typename F>
-        static inline detail::thread_data_ptr make_thread_info(F f)
-        {
-            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
-        }
-        template<typename F>
-        static inline detail::thread_data_ptr make_thread_info(boost::detail::thread_move_t<F> f)
+        static inline detail::thread_data_ptr make_thread_info(F const& f)
         {
             return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
         }
 
-#endif
         struct dummy;
     public:
 #if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
@@ -155 +154 @@
         ~thread();
 
 #ifndef BOOST_NO_RVALUE_REFERENCES
-#ifdef BOOST_MSVC
-        template <class F>
-        explicit thread(F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):
-            thread_info(make_thread_info(static_cast<F&&>(f)))
-        {
-            start_thread();
-        }
-#else
-        template <class F>
-        thread(F&& f):
-            thread_info(make_thread_info(static_cast<F&&>(f)))
-        {
-            start_thread();
-        }
-#endif
-
-        thread(thread&& other)
-        {
-            thread_info.swap(other.thread_info);
-        }
-        
         thread& operator=(thread&& other)
         {
             thread_info=other.thread_info;
             other.thread_info.reset();
             return *this;
         }
-
-        thread&& move()
-        {
-            return static_cast<thread&&>(*this);
-        }
-        
-#else
-#ifdef BOOST_NO_SFINAE
         template <class F>
-        explicit thread(F f):
-            thread_info(make_thread_info(f))
+        explicit thread(F&& f):
+            thread_info(make_thread_info(static_cast<typename boost::mpl::if_<boost::is_lvalue_reference<F>, typename boost::remove_reference<F>::type const&, F&&>::type>(f)))
         {
             start_thread();
         }
 #else
         template <class F>
-        explicit thread(F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):
-            thread_info(make_thread_info(f))
-        {
-            start_thread();
-        }
-#endif
-        
-        template <class F>
-        explicit thread(detail::thread_move_t<F> f):
+        explicit thread(F const& f,typename disable_if<boost::is_convertible<F&,rv<F>&>, dummy* >::type=0):
             thread_info(make_thread_info(f))
         {
             start_thread();
         }
 
-        thread(detail::thread_move_t<thread> x)
-        {
-            thread_info=x->thread_info;
-            x->thread_info.reset();
-        }
-       
 #if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
-        thread& operator=(thread x) 
+        thread& operator=(thread other) 
         { 
-            swap(x); 
+            swap(other); 
             return *this; 
         } 
 #else
-        thread& operator=(detail::thread_move_t<thread> x)
+        thread& operator=(BOOST_RV_REF(thread) other)
         {
-            thread new_thread(x);
+            thread new_thread(boost::move(other));
             swap(new_thread);
             return *this;
         }
-#endif   
-        operator detail::thread_move_t<thread>()
+#endif
+        template <class F>
+        explicit thread(BOOST_RV_REF(F) f):
+            thread_info(make_thread_info(boost::move(f)))
         {
-            return move();
+            start_thread();
         }
         
-        detail::thread_move_t<thread> move()
+        template <class F>
+        explicit thread(F& f):
+            thread_info(make_thread_info(f))
         {
-            detail::thread_move_t<thread> x(*this);
-            return x;
+            start_thread();    
         }
-
 #endif
 
+        template <class F>
+        explicit thread(BOOST_CATCH_CONST_RLVALUE(F) f):
+            thread_info(make_thread_info<F>(f))
+        {
+            start_thread();    
+        }
+
+        thread(BOOST_RV_REF(thread) other)
+        {
+            thread_info.swap(other.thread_info);
+        }
+
         template <class F,class A1>
         thread(F f,A1 a1):
             thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1)))
@@ -355 +325 @@
     {
         return lhs.swap(rhs);
     }
-    
-#ifndef BOOST_NO_RVALUE_REFERENCES
-    inline thread&& move(thread& t)
-    {
-        return static_cast<thread&&>(t);
-    }
-    inline thread&& move(thread&& t)
-    {
-        return static_cast<thread&&>(t);
-    }
-#else
-    inline detail::thread_move_t<thread> move(detail::thread_move_t<thread> t)
-    {
-        return t;
-    }
-#endif
 
     namespace this_thread
     {

boost/thread/future.hpp

@@ -7 +7 @@
 #ifndef BOOST_THREAD_FUTURE_HPP
 #define BOOST_THREAD_FUTURE_HPP
 #include <stdexcept>
-#include <boost/thread/detail/move.hpp>
+#include <boost/move/move.hpp>
 #include <boost/thread/thread_time.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition_variable.hpp>
@@ -16 +16 @@
 #include <boost/scoped_ptr.hpp>
 #include <boost/type_traits/is_fundamental.hpp>
 #include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_lvalue_reference.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/config.hpp>
 #include <boost/throw_exception.hpp>
@@ -229 +231 @@
             typedef typename boost::mpl::if_<boost::is_fundamental<T>,dummy&,T&&>::type rvalue_source_type;
             typedef typename boost::mpl::if_<boost::is_fundamental<T>,T,T&&>::type move_dest_type;
 #else
-            typedef T& source_reference_type;
-            typedef typename boost::mpl::if_<boost::is_convertible<T&,boost::detail::thread_move_t<T> >,boost::detail::thread_move_t<T>,T const&>::type rvalue_source_type;
-            typedef typename boost::mpl::if_<boost::is_convertible<T&,boost::detail::thread_move_t<T> >,boost::detail::thread_move_t<T>,T>::type move_dest_type;
+            typedef boost::is_convertible<T&, ::boost::rv<T>& > T_supports_move_emulation;
+            typedef typename boost::mpl::if_<T_supports_move_emulation,::boost::rv<T> const&,T&>::type source_reference_type;
+            typedef typename boost::mpl::if_<T_supports_move_emulation,::boost::rv<T>&,T const&>::type rvalue_source_type;
+            typedef typename boost::mpl::if_<T_supports_move_emulation,::boost::rv<T>&,T>::type move_dest_type;
 #endif
 
             static void init(storage_type& storage,source_reference_type t)
@@ -322 +325 @@
             void mark_finished_with_result(rvalue_source_type result_)
             {
                 boost::lock_guard<boost::mutex> lock(mutex);
-                mark_finished_with_result_internal(result_);
+                mark_finished_with_result_internal(static_cast<rvalue_source_type>(result_));
             }
 
-            move_dest_type get()
+            T& get()
             {
                 wait();
-                return static_cast<move_dest_type>(*result);
+                return *result;
             }
 
             future_state::state get_state()
@@ -616 +619 @@
     template <typename R>
     class unique_future
     {
-        unique_future(unique_future & rhs);// = delete;
-        unique_future& operator=(unique_future& rhs);// = delete;
+        BOOST_MOVABLE_BUT_NOT_COPYABLE(unique_future)
 
         typedef boost::shared_ptr<detail::future_object<R> > future_ptr;
         
@@ -643 +645 @@
         ~unique_future()
         {}
 
-#ifndef BOOST_NO_RVALUE_REFERENCES
-        unique_future(unique_future && other)
+        unique_future(BOOST_RV_REF(unique_future) other)
         {
             future.swap(other.future);
         }
-        unique_future& operator=(unique_future && other)
+        unique_future& operator=(BOOST_RV_REF(unique_future) other)
         {
             future=other.future;
             other.future.reset();
             return *this;
         }
-#else
-        unique_future(boost::detail::thread_move_t<unique_future> other):
-            future(other->future)
-        {
-            other->future.reset();
-        }
-
-        unique_future& operator=(boost::detail::thread_move_t<unique_future> other)
-        {
-            future=other->future;
-            other->future.reset();
-            return *this;
-        }
-
-        operator boost::detail::thread_move_t<unique_future>()
-        {
-            return boost::detail::thread_move_t<unique_future>(*this);
-        }
-#endif
 
         void swap(unique_future& other)
         {
@@ -687 +669 @@
                 boost::throw_exception(future_uninitialized());
             }
 
-            return future->get();
+            return static_cast<move_dest_type>(future->get());
         }
         
         // functions to check state, and wait for ready
@@ -752 +734 @@
 //         shared_future(const unique_future<R>& other);
 //         shared_future& operator=(const unique_future<R>& other);
 
+        BOOST_COPYABLE_AND_MOVABLE(shared_future)
+
         friend class detail::future_waiter;
         friend class promise<R>;
         friend class packaged_task<R>;
@@ -773 +757 @@
         ~shared_future()
         {}
 
-        shared_future& operator=(shared_future const& other)
+        shared_future& operator=(BOOST_COPY_ASSIGN_REF(shared_future) other)
         {
             future=other.future;
             return *this;
         }
-#ifndef BOOST_NO_RVALUE_REFERENCES
-        shared_future(shared_future && other)
+
+        shared_future(BOOST_RV_REF(shared_future) other)
         {
             future.swap(other.future);
         }
-        shared_future(unique_future<R> && other)
+        shared_future(BOOST_RV_REF(unique_future<R>) other)
         {
             future.swap(other.future);
         }
-        shared_future& operator=(shared_future && other)
+        shared_future& operator=(BOOST_RV_REF(shared_future) other)
         {
             future.swap(other.future);
             other.future.reset();
             return *this;
         }
-        shared_future& operator=(unique_future<R> && other)
+        shared_future& operator=(BOOST_RV_REF(unique_future<R>) other)
         {
             future.swap(other.future);
             other.future.reset();
             return *this;
         }
-#else            
-        shared_future(boost::detail::thread_move_t<shared_future> other):
-            future(other->future)
-        {
-            other->future.reset();
-        }
-//         shared_future(const unique_future<R> &) = delete;
-        shared_future(boost::detail::thread_move_t<unique_future<R> > other):
-            future(other->future)
-        {
-            other->future.reset();
-        }
-        shared_future& operator=(boost::detail::thread_move_t<shared_future> other)
-        {
-            future.swap(other->future);
-            other->future.reset();
-            return *this;
-        }
-        shared_future& operator=(boost::detail::thread_move_t<unique_future<R> > other)
-        {
-            future.swap(other->future);
-            other->future.reset();
-            return *this;
-        }
-
-        operator boost::detail::thread_move_t<shared_future>()
-        {
-            return boost::detail::thread_move_t<shared_future>(*this);
-        }
-
-#endif
 
         void swap(shared_future& other)
         {
@@ -837 +790 @@
         }
 
         // retrieving the value
-        R get()
+        R const& get()
         {
             if(!future)
             {
@@ -907 +860 @@
         future_ptr future;
         bool future_obtained;
         
-        promise(promise & rhs);// = delete;
-        promise & operator=(promise & rhs);// = delete;
+        BOOST_MOVABLE_BUT_NOT_COPYABLE(promise)
 
         void lazy_init()
         {
@@ -940 +892 @@
         }
 
         // Assignment
-#ifndef BOOST_NO_RVALUE_REFERENCES
-        promise(promise && rhs):
+        promise(BOOST_RV_REF(promise) rhs):
             future_obtained(rhs.future_obtained)
         {
             future.swap(rhs.future);
             rhs.future_obtained=false;
         }
-        promise & operator=(promise&& rhs)
+        promise & operator=(BOOST_RV_REF(promise) rhs)
         {
             future.swap(rhs.future);
             future_obtained=rhs.future_obtained;
@@ -955 +906 @@
             rhs.future_obtained=false;
             return *this;
         }
-#else
-        promise(boost::detail::thread_move_t<promise> rhs):
-            future(rhs->future),future_obtained(rhs->future_obtained)
-        {
-            rhs->future.reset();
-            rhs->future_obtained=false;
-        }
-        promise & operator=(boost::detail::thread_move_t<promise> rhs)
-        {
-            future=rhs->future;
-            future_obtained=rhs->future_obtained;
-            rhs->future.reset();
-            rhs->future_obtained=false;
-            return *this;
-        }
-
-        operator boost::detail::thread_move_t<promise>()
-        {
-            return boost::detail::thread_move_t<promise>(*this);
-        }
-#endif   
         
         void swap(promise& other)
         {
@@ -1046 +976 @@
         future_ptr future;
         bool future_obtained;
         
-        promise(promise & rhs);// = delete;
-        promise & operator=(promise & rhs);// = delete;
+        BOOST_MOVABLE_BUT_NOT_COPYABLE(promise)
 
         void lazy_init()
         {
@@ -1078 +1007 @@
         }
 
         // Assignment
-#ifndef BOOST_NO_RVALUE_REFERENCES
-        promise(promise && rhs):
+        promise(BOOST_RV_REF(promise) rhs):
             future_obtained(rhs.future_obtained)
         {
             future.swap(rhs.future);
             rhs.future_obtained=false;
         }
-        promise & operator=(promise&& rhs)
+        promise & operator=(BOOST_RV_REF(promise) rhs)
         {
             future.swap(rhs.future);
             future_obtained=rhs.future_obtained;
@@ -1093 +1021 @@
             rhs.future_obtained=false;
             return *this;
         }
-#else
-        promise(boost::detail::thread_move_t<promise> rhs):
-            future(rhs->future),future_obtained(rhs->future_obtained)
-        {
-            rhs->future.reset();
-            rhs->future_obtained=false;
-        }
-        promise & operator=(boost::detail::thread_move_t<promise> rhs)
-        {
-            future=rhs->future;
-            future_obtained=rhs->future_obtained;
-            rhs->future.reset();
-            rhs->future_obtained=false;
-            return *this;
-        }
-
-        operator boost::detail::thread_move_t<promise>()
-        {
-            return boost::detail::thread_move_t<promise>(*this);
-        }
-#endif
         
         void swap(promise& other)
         {
@@ -1209 +1116 @@
         struct task_object:
             task_base<R>
         {
+            struct dummy;
             F f;
+
             task_object(F const& f_):
                 f(f_)
             {}
-            task_object(boost::detail::thread_move_t<F> f_):
-                f(f_)
+
+            task_object(BOOST_RV_REF(F) f_):
+                f(::boost::move(f_))
             {}
             
             void do_run()
@@ -1234 +1144 @@
         struct task_object<void,F>:
             task_base<void>
         {
+            struct dummy;
             F f;
+
             task_object(F const& f_):
                 f(f_)
             {}
-            task_object(boost::detail::thread_move_t<F> f_):
+
+            task_object(BOOST_RV_REF(F) f_):
+                f(::boost::move(f_))
+            {}
+            
+            void do_run()
+            {
+                try
+                {
+                    f();
+                    this->mark_finished_with_result();
+                }
+                catch(...)
+                {
+                    this->mark_exceptional_finish();
+                }
+            }
+        };
+
+        template<typename R>
+        struct task_object<R, R (*)()>:
+            task_base<R>
+        {
+            struct dummy;
+            R (*f)();
+            
+            task_object(R f_()):
                 f(f_)
             {}
             
@@ -1246 +1184 @@
             {
                 try
                 {
+                    this->mark_finished_with_result(f());
+                }
+                catch(...)
+                {
+                    this->mark_exceptional_finish();
+                }
+            }
+        };
+
+        template<>
+        struct task_object<void, void (*)()>:
+            task_base<void>
+        {
+            struct dummy;
+            void (*f)();
+
+            task_object(void f_()):
+                f(f_)
+            {}
+
+            void do_run()
+            {
+                try
+                {
                     f();
                     this->mark_finished_with_result();
                 }
@@ -1265 +1227 @@
         boost::shared_ptr<detail::task_base<R> > task;
         bool future_obtained;
 
-        packaged_task(packaged_task&);// = delete;
-        packaged_task& operator=(packaged_task&);// = delete;
-        
+        BOOST_MOVABLE_BUT_NOT_COPYABLE(packaged_task)
+        struct dummy;
     public:
         packaged_task():
             future_obtained(false)
         {}
         
         // construction and destruction
+#ifdef BOOST_NO_RVALUE_REFERENCES
         template <class F>
-        explicit packaged_task(F const& f):
+        explicit packaged_task(F const& f, typename ::boost::disable_if< ::boost::is_convertible<F&,::boost::rv<F>&>,dummy*>::type=0):
             task(new detail::task_object<R,F>(f)),future_obtained(false)
         {}
-        explicit packaged_task(R(*f)()):
-            task(new detail::task_object<R,R(*)()>(f)),future_obtained(false)
+        
+        template <class F>
+        explicit packaged_task(F& f):
+            task(new detail::task_object<R,F>(f)),future_obtained(false)
         {}
         
         template <class F>
-        explicit packaged_task(boost::detail::thread_move_t<F> f):
+        explicit packaged_task(BOOST_RV_REF(F) f):
+            task(new detail::task_object<R,F>(boost::move(f))),future_obtained(false)
+        {}
+
+        template <class F>
+        explicit packaged_task(BOOST_CATCH_CONST_RLVALUE(F) f):
             task(new detail::task_object<R,F>(f)),future_obtained(false)
         {}
+#else
+        template <class F>
+        explicit packaged_task(F&& f):
+            task(new detail::task_object<R,typename boost::remove_reference<F>::type>(
+                static_cast<typename boost::mpl::if_<boost::is_lvalue_reference<F>,
+                    typename boost::remove_reference<F>::type const&, F&&>::type>(f))),
+            future_obtained(false)
+        {}
+#endif
 
+        explicit packaged_task(R(*f)()):
+            task(new detail::task_object<R,R(*)()>(f)),future_obtained(false)
+        {}
+        
+
+        
 //         template <class F, class Allocator>
 //         explicit packaged_task(F const& f, Allocator a);
 //         template <class F, class Allocator>
@@ -1302 +1286 @@
         }
 
         // assignment
-#ifndef BOOST_NO_RVALUE_REFERENCES
-        packaged_task(packaged_task&& other):
+        packaged_task(BOOST_RV_REF(packaged_task) other):
             future_obtained(other.future_obtained)
         {
             task.swap(other.task);
             other.future_obtained=false;
         }
-        packaged_task& operator=(packaged_task&& other)
-        {
-            packaged_task temp(static_cast<packaged_task&&>(other));
-            swap(temp);
-            return *this;
-        }
-#else
-        packaged_task(boost::detail::thread_move_t<packaged_task> other):
-            future_obtained(other->future_obtained)
-        {
-            task.swap(other->task);
-            other->future_obtained=false;
-        }
-        packaged_task& operator=(boost::detail::thread_move_t<packaged_task> other)
+        packaged_task& operator=(BOOST_RV_REF(packaged_task) other)
         {
-            packaged_task temp(other);
+            packaged_task temp(boost::move(other));
             swap(temp);
             return *this;
         }
-        operator boost::detail::thread_move_t<packaged_task>()
-        {
-            return boost::detail::thread_move_t<packaged_task>(*this);
-        }
-#endif
 
         void swap(packaged_task& other)
         {

boost/thread/locks.hpp

@@ -6 +6 @@
 #define BOOST_THREAD_LOCKS_HPP
 #include <boost/thread/detail/config.hpp>
 #include <boost/thread/exceptions.hpp>
-#include <boost/thread/detail/move.hpp>
+#include <boost/move/move.hpp>
 #include <algorithm>
 #include <iterator>
 #include <boost/thread/thread_time.hpp>
@@ -272 +272 @@
     private:
         Mutex* m;
         bool is_locked;
-        unique_lock(unique_lock&);
         explicit unique_lock(upgrade_lock<Mutex>&);
-        unique_lock& operator=(unique_lock&);
-        unique_lock& operator=(upgrade_lock<Mutex>& other);
+        BOOST_MOVABLE_BUT_NOT_COPYABLE(unique_lock);
     public:
 #if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) 
         unique_lock(const volatile unique_lock&); 
@@ -311 +309 @@
         {
             timed_lock(target_time);
         }
-#ifndef BOOST_NO_RVALUE_REFERENCES
-        unique_lock(unique_lock&& other):
+
+        unique_lock(BOOST_RV_REF(unique_lock) other):
             m(other.m),is_locked(other.is_locked)
         {
             other.is_locked=false;
             other.m=0;
         }
-        explicit unique_lock(upgrade_lock<Mutex>&& other);
-
-        unique_lock<Mutex>&& move()
-        {
-            return static_cast<unique_lock<Mutex>&&>(*this);
-        }
-
+        explicit unique_lock(BOOST_RV_REF(upgrade_lock<Mutex>) other);
 
-        unique_lock& operator=(unique_lock&& other)
+        unique_lock& operator=(BOOST_RV_REF(unique_lock) other)
         {
             unique_lock temp(other.move());
             swap(temp);
             return *this;
         }
 
-        unique_lock& operator=(upgrade_lock<Mutex>&& other)
+        unique_lock& operator=(BOOST_RV_REF(upgrade_lock<Mutex>) other)
         {
             unique_lock temp(other.move());
             swap(temp);
             return *this;
         }
-        void swap(unique_lock&& other)
+        void swap(BOOST_RV_REF(unique_lock) other)
         {
             std::swap(m,other.m);
             std::swap(is_locked,other.is_locked);
         }
-#else
-        unique_lock(detail::thread_move_t<unique_lock<Mutex> > other):
-            m(other->m),is_locked(other->is_locked)
-        {
-            other->is_locked=false;
-            other->m=0;
-        }
-        unique_lock(detail::thread_move_t<upgrade_lock<Mutex> > other);
-
-        operator detail::thread_move_t<unique_lock<Mutex> >()
-        {
-            return move();
-        }
-
-        detail::thread_move_t<unique_lock<Mutex> > move()
-        {
-            return detail::thread_move_t<unique_lock<Mutex> >(*this);
-        }
 
-#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) 
-        unique_lock& operator=(unique_lock<Mutex> other) 
-        { 
-            swap(other); 
-            return *this; 
-        } 
-#else
-        unique_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
-        {
-            unique_lock temp(other);
-            swap(temp);
-            return *this;
-        }
-#endif
-
-        unique_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)
-        {
-            unique_lock temp(other);
-            swap(temp);
-            return *this;
-        }
-        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);
@@ -479 +426 @@
         friend class upgrade_lock<Mutex>;
     };
 
-#ifndef BOOST_NO_RVALUE_REFERENCES
-    template<typename Mutex>
-    void swap(unique_lock<Mutex>&& lhs,unique_lock<Mutex>&& rhs)
-    {
-        lhs.swap(rhs);
-    }
 
     template<typename Mutex>
-    inline upgrade_lock<Mutex>&& move(upgrade_lock<Mutex>&& ul)
+    void swap(BOOST_RV_REF(unique_lock<Mutex>) lhs, BOOST_RV_REF(unique_lock<Mutex>) rhs)
     {
-        return static_cast<upgrade_lock<Mutex>&&>(ul);
+        lhs.swap(rhs);
     }
 
     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);
     }
 
-#ifndef BOOST_NO_RVALUE_REFERENCES
-    template<typename Mutex>
-    inline unique_lock<Mutex>&& move(unique_lock<Mutex>&& 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
-
     template<typename Mutex>
     class shared_lock
     {
@@ -525 +446 @@
         Mutex* m;
         bool is_locked;
     private:
-        explicit shared_lock(shared_lock&);
-        shared_lock& operator=(shared_lock&);
+        BOOST_MOVABLE_BUT_NOT_COPYABLE(shared_lock)
     public:
         shared_lock():
             m(0),is_locked(false)
@@ -554 +474 @@
             timed_lock(target_time);
         }
 
-        shared_lock(detail::thread_move_t<shared_lock<Mutex> > other):
+        shared_lock(BOOST_RV_REF(shared_lock<Mutex>) other):
             m(other->m),is_locked(other->is_locked)
         {
             other->is_locked=false;
             other->m=0;
         }
 
-        shared_lock(detail::thread_move_t<unique_lock<Mutex> > other):
+        shared_lock(BOOST_RV_REF(unique_lock<Mutex>) other):
             m(other->m),is_locked(other->is_locked)
         {
             if(is_locked)
@@ -572 +492 @@
             other->m=0;
         }
 
-        shared_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):
+        shared_lock(BOOST_RV_REF(upgrade_lock<Mutex>) other):
             m(other->m),is_locked(other->is_locked)
         {
             if(is_locked)
@@ -583 +503 @@
             other->m=0;
         }
 
-        operator detail::thread_move_t<shared_lock<Mutex> >()
-        {
-            return move();
-        }
-
-        detail::thread_move_t<shared_lock<Mutex> > move()
-        {
-            return detail::thread_move_t<shared_lock<Mutex> >(*this);
-        }
-
-
-        shared_lock& operator=(detail::thread_move_t<shared_lock<Mutex> > other)
+        shared_lock& operator=(BOOST_RV_REF(shared_lock<Mutex>) other)
         {
             shared_lock temp(other);
             swap(temp);
             return *this;
         }
 
-        shared_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
+        shared_lock& operator=(BOOST_RV_REF(unique_lock<Mutex>) other)
         {
             shared_lock temp(other);
             swap(temp);
             return *this;
         }
 
-        shared_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)
+        shared_lock& operator=(BOOST_RV_REF(upgrade_lock<Mutex>) other)
         {
             shared_lock temp(other);
             swap(temp);
             return *this;
         }
 
-#ifndef BOOST_NO_RVALUE_REFERENCES
-        void swap(shared_lock&& other)
+        void swap(BOOST_RV_REF(shared_lock) other)
         {
             std::swap(m,other.m);
             std::swap(is_locked,other.is_locked);
         }
-#else
-        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);
@@ -709 +611 @@
 
     };
 
-#ifndef BOOST_NO_RVALUE_REFERENCES
-    template<typename Mutex>
-    void swap(shared_lock<Mutex>&& lhs,shared_lock<Mutex>&& rhs)
-    {
-        lhs.swap(rhs);
-    }
-#else
     template<typename Mutex>
-    void swap(shared_lock<Mutex>& lhs,shared_lock<Mutex>& rhs)
+    void swap(BOOST_RV_REF(shared_lock<Mutex>) lhs,BOOST_RV_REF(shared_lock<Mutex>) rhs)
     {
         lhs.swap(rhs);
     }
-#endif
 
     template<typename Mutex>
     class upgrade_lock
@@ -730 +624 @@
         Mutex* m;
         bool is_locked;
     private:
-        explicit upgrade_lock(upgrade_lock&);
-        upgrade_lock& operator=(upgrade_lock&);
+        BOOST_MOVABLE_BUT_NOT_COPYABLE(upgrade_lock)
     public:
         upgrade_lock():
             m(0),is_locked(false)
@@ -753 +646 @@
         {
             try_lock();
         }
-#ifdef BOOST_HAS_RVALUE_REFS
-        upgrade_lock(upgrade_lock<Mutex>&& other):
+
+        upgrade_lock(BOOST_RV_REF(upgrade_lock) other):
             m(other.m),is_locked(other.is_locked)
         {
             other.is_locked=false;
             other.m=0;
         }
 
-        upgrade_lock(unique_lock<Mutex>&& other):
+        upgrade_lock(BOOST_RV_REF(unique_lock<Mutex>) other):
             m(other.m),is_locked(other.is_locked)
         {
             if(is_locked)
@@ -772 +665 @@
             other.m=0;
         }
 
-        upgrade_lock& operator=(upgrade_lock<Mutex>&& other)
+        upgrade_lock& operator=(BOOST_RV_REF(upgrade_lock) other)
         {
-            upgrade_lock temp(static_cast<upgrade_lock<Mutex>&&>(other));
+            upgrade_lock temp(boost::move(other));
             swap(temp);
             return *this;
         }
 
-        upgrade_lock& operator=(unique_lock<Mutex>&& other)
+        upgrade_lock& operator=(BOOST_RV_REF(unique_lock<Mutex>) other)
         {
-            upgrade_lock temp(static_cast<unique_lock<Mutex>&&>(other));
+            upgrade_lock temp(boost::move(other));
             swap(temp);
             return *this;
         }
-#else
-        upgrade_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):
-            m(other->m),is_locked(other->is_locked)
-        {
-            other->is_locked=false;
-            other->m=0;
-        }
-
-        upgrade_lock(detail::thread_move_t<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;
-        }
-
-        operator detail::thread_move_t<upgrade_lock<Mutex> >()
-        {
-            return move();
-        }
-
-        detail::thread_move_t<upgrade_lock<Mutex> > move()
-        {
-            return detail::thread_move_t<upgrade_lock<Mutex> >(*this);
-        }
-
-
-        upgrade_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)
-        {
-            upgrade_lock temp(other);
-            swap(temp);
-            return *this;
-        }
-
-        upgrade_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
-        {
-            upgrade_lock temp(other);
-            swap(temp);
-            return *this;
-        }
-#endif
 
         void swap(upgrade_lock& other)
         {
@@ -888 +737 @@
         friend class unique_lock<Mutex>;
     };
 
-
-#ifndef BOOST_NO_RVALUE_REFERENCES
     template<typename Mutex>
-    unique_lock<Mutex>::unique_lock(upgrade_lock<Mutex>&& other):
+    unique_lock<Mutex>::unique_lock(BOOST_RV_REF(upgrade_lock<Mutex>) other):
         m(other.m),is_locked(other.is_locked)
     {
         other.is_locked=false;
@@ -900 +747 @@
             m->unlock_upgrade_and_lock();
         }
     }
-#else
-    template<typename Mutex>
-    unique_lock<Mutex>::unique_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):
-        m(other->m),is_locked(other->is_locked)
-    {
-        other->is_locked=false;
-        if(is_locked)
-        {
-            m->unlock_upgrade_and_lock();
-        }
-    }
-#endif
+
     template <class Mutex>
     class upgrade_to_unique_lock
     {
@@ -919 +755 @@
         upgrade_lock<Mutex>* source;
         unique_lock<Mutex> exclusive;
 
-        explicit upgrade_to_unique_lock(upgrade_to_unique_lock&);
-        upgrade_to_unique_lock& operator=(upgrade_to_unique_lock&);
+        BOOST_MOVABLE_BUT_NOT_COPYABLE(upgrade_to_unique_lock)
     public:
         explicit upgrade_to_unique_lock(upgrade_lock<Mutex>& m_):
-            source(&m_),exclusive(move(*source))
+            source(&m_),exclusive(boost::move(*source))
         {}
         ~upgrade_to_unique_lock()
         {
             if(source)
             {
-                *source=move(exclusive);
+                *source=boost::move(exclusive);
             }
         }
 
-#ifdef BOOST_HAS_RVALUE_REFS
-        upgrade_to_unique_lock(upgrade_to_unique_lock<Mutex>&& other):
-            source(other.source),exclusive(move(other.exclusive))
+        upgrade_to_unique_lock(BOOST_RV_REF(upgrade_to_unique_lock<Mutex>) other):
+            source(other.source),exclusive(boost::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))
-        {
-            other->source=0;
-        }
-        
-        upgrade_to_unique_lock& operator=(detail::thread_move_t<upgrade_to_unique_lock<Mutex> > other)
+        upgrade_to_unique_lock& operator=(BOOST_RV_REF(upgrade_to_unique_lock<Mutex>) other)
         {
             upgrade_to_unique_lock temp(other);
             swap(temp);
             return *this;
         }
-#endif
+
         void swap(upgrade_to_unique_lock& other)
         {
             std::swap(source,other.source);
@@ -986 +807 @@
         class try_lock_wrapper:
             private unique_lock<Mutex>
         {
+            BOOST_MOVABLE_BUT_NOT_COPYABLE(try_lock_wrapper)
             typedef unique_lock<Mutex> base;
         public:
             try_lock_wrapper()
@@ -1004 +826 @@
             try_lock_wrapper(Mutex& m_,try_to_lock_t):
                 base(m_,try_to_lock)
             {}
-#ifndef BOOST_NO_RVALUE_REFERENCES
-            try_lock_wrapper(try_lock_wrapper&& other):
-                base(other.move())
-            {}
 
-            try_lock_wrapper&& move()
-            {
-                return static_cast<try_lock_wrapper&&>(*this);
-            }
-
-            try_lock_wrapper& operator=(try_lock_wrapper<Mutex>&& other)
+            try_lock_wrapper(BOOST_RV_REF(try_lock_wrapper) other):
+                base(boost::move(static_cast<base&>(other)))
+            {}
+            
+            try_lock_wrapper& operator=(BOOST_RV_REF(try_lock_wrapper<Mutex>) other)
             {
                 try_lock_wrapper temp(other.move());
                 swap(temp);
                 return *this;
             }
 
-            void swap(try_lock_wrapper&& other)
+            void swap(BOOST_RV_REF(try_lock_wrapper) other)
             {
                 base::swap(other);
             }
-#else
-            try_lock_wrapper(detail::thread_move_t<try_lock_wrapper<Mutex> > other):
-                base(detail::thread_move_t<base>(*other))
-            {}
-
-            operator detail::thread_move_t<try_lock_wrapper<Mutex> >()
-            {
-                return move();
-            }
-
-            detail::thread_move_t<try_lock_wrapper<Mutex> > move()
-            {
-                return detail::thread_move_t<try_lock_wrapper<Mutex> >(*this);
-            }
-
-            try_lock_wrapper& operator=(detail::thread_move_t<try_lock_wrapper<Mutex> > other)
-            {
-                try_lock_wrapper temp(other);
-                swap(temp);
-                return *this;
-            }
 
-            void swap(detail::thread_move_t<try_lock_wrapper<Mutex> > other)
-            {
-                base::swap(*other);
-            }
-#endif
             void swap(try_lock_wrapper& other)
             {
                 base::swap(other);
@@ -1092 +883 @@
             }
         };
 
-#ifndef BOOST_NO_RVALUE_REFERENCES
         template<typename Mutex>
-        void swap(try_lock_wrapper<Mutex>&& lhs,try_lock_wrapper<Mutex>&& rhs)
+        void swap(BOOST_RV_REF(try_lock_wrapper<Mutex>) lhs,BOOST_RV_REF(try_lock_wrapper<Mutex>) rhs)
         {
             lhs.swap(rhs);
         }
-#else
-        template<typename Mutex>
-        void swap(try_lock_wrapper<Mutex>& lhs,try_lock_wrapper<Mutex>& rhs)
-        {
-            lhs.swap(rhs);
-        }
-#endif
         
         template<typename MutexType1,typename MutexType2>
         unsigned try_lock_internal(MutexType1& m1,MutexType2& m2)