Ticket #6194: 6194_1.patch

File 6194_1.patch, 37.5 KB (added by Evan Wallace <onlyone@…>, 11 years ago)

Version 1 of the patch to #6194

  • boost/thread/detail/thread.hpp 

    Only in boost_1_48_0/boost/thread/detail: move.hpp
diff -ur boost_1_48_0/boost/thread/detail/thread.hpp boost_1_48_0_patched/boost/thread/detail/thread.hpp
    old new  
    99#ifndef BOOST_NO_IOSTREAM
    1010#include <ostream>
    1111#endif
    12 #include <boost/thread/detail/move.hpp>
     12#include <boost/move/move.hpp>
    1313#include <boost/thread/mutex.hpp>
    1414#include <boost/thread/xtime.hpp>
    1515#include <boost/thread/detail/thread_heap_alloc.hpp>
    … …  
    2222#include <boost/bind.hpp>
    2323#include <stdlib.h>
    2424#include <memory>
    25 #include <boost/utility/enable_if.hpp>
    26 #include <boost/type_traits/remove_reference.hpp>
     25#include <boost/type_traits/decay.hpp>
    2726
    2827#include <boost/config/abi_prefix.hpp>
    2928
    … …  
    4140            public detail::thread_data_base
    4241        {
    4342        public:
    44 #ifndef BOOST_NO_RVALUE_REFERENCES
    45             thread_data(F&& f_):
    46                 f(static_cast<F&&>(f_))
     43            thread_data(BOOST_RV_REF(F) f_):
     44                f(boost::move(f_))
    4745            {}
    48             thread_data(F& f_):
     46            thread_data(F const& f_):
    4947                f(f_)
    5048            {}
    51 #else
    52             thread_data(F f_):
    53                 f(f_)
    54             {}
    55             thread_data(detail::thread_move_t<F> f_):
    56                 f(f_)
    57             {}
    58 #endif           
    5949            void run()
    6050            {
    6151                f();
    … …  
    110100    class BOOST_THREAD_DECL thread
    111101    {
    112102    private:
    113         thread(thread&);
    114         thread& operator=(thread&);
    115 
     103        BOOST_MOVABLE_BUT_NOT_COPYABLE(thread)
    116104        void release_handle();
    117105       
    118106        detail::thread_data_ptr thread_info;
    … …  
    123111
    124112        detail::thread_data_ptr get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const;
    125113
     114
    126115#ifndef BOOST_NO_RVALUE_REFERENCES
    127116        template<typename F>
    128117        static inline detail::thread_data_ptr make_thread_info(F&& f)
    129118        {
    130             return detail::thread_data_ptr(detail::heap_new<detail::thread_data<typename boost::remove_reference<F>::type> >(static_cast<F&&>(f)));
    131         }
    132         static inline detail::thread_data_ptr make_thread_info(void (*f)())
    133         {
    134             return detail::thread_data_ptr(detail::heap_new<detail::thread_data<void(*)()> >(static_cast<void(*&&)()>(f)));
     119            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<typename boost::decay<F>::type> >(boost::forward<F>(f)));
    135120        }
    136121#else
     122        struct dummy;
    137123        template<typename F>
    138         static inline detail::thread_data_ptr make_thread_info(F f)
     124        static inline detail::thread_data_ptr make_thread_info(F& f)
    139125        {
    140126            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
    141127        }
     128       
    142129        template<typename F>
    143         static inline detail::thread_data_ptr make_thread_info(boost::detail::thread_move_t<F> f)
     130        static inline detail::thread_data_ptr make_thread_info(BOOST_RV_REF(F) f)
    144131        {
    145             return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
     132            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(boost::move(f)));
    146133        }
    147 
    148134#endif
    149         struct dummy;
     135
    150136    public:
    151137#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
    152138        thread(const volatile thread&);
    … …  
    155141        ~thread();
    156142
    157143#ifndef BOOST_NO_RVALUE_REFERENCES
    158 #ifdef BOOST_MSVC
    159         template <class F>
    160         explicit thread(F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):
    161             thread_info(make_thread_info(static_cast<F&&>(f)))
    162         {
    163             start_thread();
    164         }
    165 #else
    166         template <class F>
    167         thread(F&& f):
    168             thread_info(make_thread_info(static_cast<F&&>(f)))
    169         {
    170             start_thread();
    171         }
    172 #endif
    173 
    174         thread(thread&& other)
    175         {
    176             thread_info.swap(other.thread_info);
    177         }
    178        
    179144        thread& operator=(thread&& other)
    180145        {
    181146            thread_info=other.thread_info;
    182147            other.thread_info.reset();
    183148            return *this;
    184149        }
    185 
    186         thread&& move()
    187         {
    188             return static_cast<thread&&>(*this);
    189         }
    190        
    191 #else
    192 #ifdef BOOST_NO_SFINAE
    193150        template <class F>
    194         explicit thread(F f):
    195             thread_info(make_thread_info(f))
     151        explicit thread(F&& f):
     152            thread_info(make_thread_info(boost::forward<F>(f)))
    196153        {
    197154            start_thread();
    198155        }
    199156#else
    200         template <class F>
    201         explicit thread(F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):
    202             thread_info(make_thread_info(f))
    203         {
    204             start_thread();
    205         }
    206 #endif
    207        
    208         template <class F>
    209         explicit thread(detail::thread_move_t<F> f):
    210             thread_info(make_thread_info(f))
    211         {
    212             start_thread();
    213         }
    214 
    215         thread(detail::thread_move_t<thread> x)
    216         {
    217             thread_info=x->thread_info;
    218             x->thread_info.reset();
    219         }
    220        
    221157#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
    222         thread& operator=(thread x)
     158        thread& operator=(thread other)
    223159        {
    224             swap(x);
     160            swap(other);
    225161            return *this;
    226162        }
    227163#else
    228         thread& operator=(detail::thread_move_t<thread> x)
     164        thread& operator=(BOOST_RV_REF(thread) other)
    229165        {
    230             thread new_thread(x);
     166            thread new_thread(boost::move(other));
    231167            swap(new_thread);
    232168            return *this;
    233169        }
    234 #endif   
    235         operator detail::thread_move_t<thread>()
     170#endif 
     171        template <class F>
     172        explicit thread(BOOST_RV_REF(F) f):
     173            thread_info(make_thread_info(boost::move(f)))
    236174        {
    237             return move();
     175            start_thread();   
    238176        }
    239        
    240         detail::thread_move_t<thread> move()
     177        template <class F>
     178        explicit thread(F f):
     179            thread_info(make_thread_info(boost::move(f)))
    241180        {
    242             detail::thread_move_t<thread> x(*this);
    243             return x;
     181            start_thread();   
    244182        }
    245 
    246183#endif
    247184
     185        thread(BOOST_RV_REF(thread) other)
     186        {
     187            thread_info.swap(other.thread_info);
     188        }
     189
    248190        template <class F,class A1>
    249191        thread(F f,A1 a1):
    250192            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1)))
    … …  
    355297    {
    356298        return lhs.swap(rhs);
    357299    }
    358    
    359 #ifndef BOOST_NO_RVALUE_REFERENCES
    360     inline thread&& move(thread& t)
    361     {
    362         return static_cast<thread&&>(t);
    363     }
    364     inline thread&& move(thread&& t)
    365     {
    366         return static_cast<thread&&>(t);
    367     }
    368 #else
    369     inline detail::thread_move_t<thread> move(detail::thread_move_t<thread> t)
    370     {
    371         return t;
    372     }
    373 #endif
    374300
    375301    namespace this_thread
    376302    {

  • boost/thread/future.hpp 

    diff -ur boost_1_48_0/boost/thread/future.hpp boost_1_48_0_patched/boost/thread/future.hpp
    old new  
    77#ifndef BOOST_THREAD_FUTURE_HPP
    88#define BOOST_THREAD_FUTURE_HPP
    99#include <stdexcept>
    10 #include <boost/thread/detail/move.hpp>
     10#include <boost/move/move.hpp>
    1111#include <boost/thread/thread_time.hpp>
    1212#include <boost/thread/mutex.hpp>
    1313#include <boost/thread/condition_variable.hpp>
    … …  
    1515#include <boost/shared_ptr.hpp>
    1616#include <boost/scoped_ptr.hpp>
    1717#include <boost/type_traits/is_fundamental.hpp>
    18 #include <boost/type_traits/is_convertible.hpp>
     18#include <boost/type_traits/decay.hpp>
    1919#include <boost/mpl/if.hpp>
    2020#include <boost/config.hpp>
    2121#include <boost/throw_exception.hpp>
    … …  
    229229            typedef typename boost::mpl::if_<boost::is_fundamental<T>,dummy&,T&&>::type rvalue_source_type;
    230230            typedef typename boost::mpl::if_<boost::is_fundamental<T>,T,T&&>::type move_dest_type;
    231231#else
    232             typedef T& source_reference_type;
    233             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;
    234             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;
     232            typedef typename boost::mpl::if_<boost::has_move_emulation_enabled<T>,::boost::rv<T> const&,T&>::type source_reference_type;
     233            typedef typename boost::mpl::if_<boost::has_move_emulation_enabled<T>,::boost::rv<T>&,T const&>::type rvalue_source_type;
     234            typedef typename boost::mpl::if_<boost::has_move_emulation_enabled<T>,::boost::rv<T>&,T>::type move_dest_type;
    235235#endif
    236236
    237237            static void init(storage_type& storage,source_reference_type t)
    … …  
    322322            void mark_finished_with_result(rvalue_source_type result_)
    323323            {
    324324                boost::lock_guard<boost::mutex> lock(mutex);
    325                 mark_finished_with_result_internal(result_);
     325                mark_finished_with_result_internal(static_cast<rvalue_source_type>(result_));
    326326            }
    327327
    328             move_dest_type get()
     328            T& get()
    329329            {
    330330                wait();
    331                 return static_cast<move_dest_type>(*result);
     331                return *result;
    332332            }
    333333
    334334            future_state::state get_state()
    … …  
    616616    template <typename R>
    617617    class unique_future
    618618    {
    619         unique_future(unique_future & rhs);// = delete;
    620         unique_future& operator=(unique_future& rhs);// = delete;
     619        BOOST_MOVABLE_BUT_NOT_COPYABLE(unique_future)
    621620
    622621        typedef boost::shared_ptr<detail::future_object<R> > future_ptr;
    623622       
    … …  
    643642        ~unique_future()
    644643        {}
    645644
    646 #ifndef BOOST_NO_RVALUE_REFERENCES
    647         unique_future(unique_future && other)
     645        unique_future(BOOST_RV_REF(unique_future) other)
    648646        {
    649647            future.swap(other.future);
    650648        }
    651         unique_future& operator=(unique_future && other)
     649        unique_future& operator=(BOOST_RV_REF(unique_future) other)
    652650        {
    653651            future=other.future;
    654652            other.future.reset();
    655653            return *this;
    656654        }
    657 #else
    658         unique_future(boost::detail::thread_move_t<unique_future> other):
    659             future(other->future)
    660         {
    661             other->future.reset();
    662         }
    663 
    664         unique_future& operator=(boost::detail::thread_move_t<unique_future> other)
    665         {
    666             future=other->future;
    667             other->future.reset();
    668             return *this;
    669         }
    670 
    671         operator boost::detail::thread_move_t<unique_future>()
    672         {
    673             return boost::detail::thread_move_t<unique_future>(*this);
    674         }
    675 #endif
    676655
    677656        void swap(unique_future& other)
    678657        {
    … …  
    687666                boost::throw_exception(future_uninitialized());
    688667            }
    689668
    690             return future->get();
     669            return static_cast<move_dest_type>(future->get());
    691670        }
    692671       
    693672        // functions to check state, and wait for ready
    … …  
    752731//         shared_future(const unique_future<R>& other);
    753732//         shared_future& operator=(const unique_future<R>& other);
    754733
     734        BOOST_COPYABLE_AND_MOVABLE(shared_future)
     735
    755736        friend class detail::future_waiter;
    756737        friend class promise<R>;
    757738        friend class packaged_task<R>;
    … …  
    773754        ~shared_future()
    774755        {}
    775756
    776         shared_future& operator=(shared_future const& other)
     757        shared_future& operator=(BOOST_COPY_ASSIGN_REF(shared_future) other)
    777758        {
    778759            future=other.future;
    779760            return *this;
    780761        }
    781 #ifndef BOOST_NO_RVALUE_REFERENCES
    782         shared_future(shared_future && other)
     762
     763        shared_future(BOOST_RV_REF(shared_future) other)
    783764        {
    784765            future.swap(other.future);
    785766        }
    786         shared_future(unique_future<R> && other)
     767        shared_future(BOOST_RV_REF(unique_future<R>) other)
    787768        {
    788769            future.swap(other.future);
    789770        }
    790         shared_future& operator=(shared_future && other)
     771        shared_future& operator=(BOOST_RV_REF(shared_future) other)
    791772        {
    792773            future.swap(other.future);
    793774            other.future.reset();
    794775            return *this;
    795776        }
    796         shared_future& operator=(unique_future<R> && other)
     777        shared_future& operator=(BOOST_RV_REF(unique_future<R>) other)
    797778        {
    798779            future.swap(other.future);
    799780            other.future.reset();
    800781            return *this;
    801782        }
    802 #else           
    803         shared_future(boost::detail::thread_move_t<shared_future> other):
    804             future(other->future)
    805         {
    806             other->future.reset();
    807         }
    808 //         shared_future(const unique_future<R> &) = delete;
    809         shared_future(boost::detail::thread_move_t<unique_future<R> > other):
    810             future(other->future)
    811         {
    812             other->future.reset();
    813         }
    814         shared_future& operator=(boost::detail::thread_move_t<shared_future> other)
    815         {
    816             future.swap(other->future);
    817             other->future.reset();
    818             return *this;
    819         }
    820         shared_future& operator=(boost::detail::thread_move_t<unique_future<R> > other)
    821         {
    822             future.swap(other->future);
    823             other->future.reset();
    824             return *this;
    825         }
    826 
    827         operator boost::detail::thread_move_t<shared_future>()
    828         {
    829             return boost::detail::thread_move_t<shared_future>(*this);
    830         }
    831 
    832 #endif
    833783
    834784        void swap(shared_future& other)
    835785        {
    … …  
    837787        }
    838788
    839789        // retrieving the value
    840         R get()
     790        R const& get()
    841791        {
    842792            if(!future)
    843793            {
    … …  
    907857        future_ptr future;
    908858        bool future_obtained;
    909859       
    910         promise(promise & rhs);// = delete;
    911         promise & operator=(promise & rhs);// = delete;
     860        BOOST_MOVABLE_BUT_NOT_COPYABLE(promise)
    912861
    913862        void lazy_init()
    914863        {
    … …  
    940889        }
    941890
    942891        // Assignment
    943 #ifndef BOOST_NO_RVALUE_REFERENCES
    944         promise(promise && rhs):
     892        promise(BOOST_RV_REF(promise) rhs):
    945893            future_obtained(rhs.future_obtained)
    946894        {
    947895            future.swap(rhs.future);
    948896            rhs.future_obtained=false;
    949897        }
    950         promise & operator=(promise&& rhs)
     898        promise & operator=(BOOST_RV_REF(promise) rhs)
    951899        {
    952900            future.swap(rhs.future);
    953901            future_obtained=rhs.future_obtained;
    … …  
    955903            rhs.future_obtained=false;
    956904            return *this;
    957905        }
    958 #else
    959         promise(boost::detail::thread_move_t<promise> rhs):
    960             future(rhs->future),future_obtained(rhs->future_obtained)
    961         {
    962             rhs->future.reset();
    963             rhs->future_obtained=false;
    964         }
    965         promise & operator=(boost::detail::thread_move_t<promise> rhs)
    966         {
    967             future=rhs->future;
    968             future_obtained=rhs->future_obtained;
    969             rhs->future.reset();
    970             rhs->future_obtained=false;
    971             return *this;
    972         }
    973 
    974         operator boost::detail::thread_move_t<promise>()
    975         {
    976             return boost::detail::thread_move_t<promise>(*this);
    977         }
    978 #endif   
    979906       
    980907        void swap(promise& other)
    981908        {
    … …  
    1046973        future_ptr future;
    1047974        bool future_obtained;
    1048975       
    1049         promise(promise & rhs);// = delete;
    1050         promise & operator=(promise & rhs);// = delete;
     976        BOOST_MOVABLE_BUT_NOT_COPYABLE(promise)
    1051977
    1052978        void lazy_init()
    1053979        {
    … …  
    10781004        }
    10791005
    10801006        // Assignment
    1081 #ifndef BOOST_NO_RVALUE_REFERENCES
    1082         promise(promise && rhs):
     1007        promise(BOOST_RV_REF(promise) rhs):
    10831008            future_obtained(rhs.future_obtained)
    10841009        {
    10851010            future.swap(rhs.future);
    10861011            rhs.future_obtained=false;
    10871012        }
    1088         promise & operator=(promise&& rhs)
     1013        promise & operator=(BOOST_RV_REF(promise) rhs)
    10891014        {
    10901015            future.swap(rhs.future);
    10911016            future_obtained=rhs.future_obtained;
    … …  
    10931018            rhs.future_obtained=false;
    10941019            return *this;
    10951020        }
    1096 #else
    1097         promise(boost::detail::thread_move_t<promise> rhs):
    1098             future(rhs->future),future_obtained(rhs->future_obtained)
    1099         {
    1100             rhs->future.reset();
    1101             rhs->future_obtained=false;
    1102         }
    1103         promise & operator=(boost::detail::thread_move_t<promise> rhs)
    1104         {
    1105             future=rhs->future;
    1106             future_obtained=rhs->future_obtained;
    1107             rhs->future.reset();
    1108             rhs->future_obtained=false;
    1109             return *this;
    1110         }
    1111 
    1112         operator boost::detail::thread_move_t<promise>()
    1113         {
    1114             return boost::detail::thread_move_t<promise>(*this);
    1115         }
    1116 #endif
    11171021       
    11181022        void swap(promise& other)
    11191023        {
    … …  
    12091113        struct task_object:
    12101114            task_base<R>
    12111115        {
     1116            struct dummy;
    12121117            F f;
     1118
    12131119            task_object(F const& f_):
    12141120                f(f_)
    12151121            {}
    1216             task_object(boost::detail::thread_move_t<F> f_):
    1217                 f(f_)
     1122
     1123            task_object(BOOST_RV_REF(F) f_):
     1124                f(::boost::move(f_))
    12181125            {}
    12191126           
    12201127            void do_run()
    … …  
    12341141        struct task_object<void,F>:
    12351142            task_base<void>
    12361143        {
     1144            struct dummy;
    12371145            F f;
     1146
    12381147            task_object(F const& f_):
    12391148                f(f_)
    12401149            {}
    1241             task_object(boost::detail::thread_move_t<F> f_):
    1242                 f(f_)
     1150
     1151            task_object(BOOST_RV_REF(F) f_):
     1152                f(::boost::move(f_))
    12431153            {}
    12441154           
    12451155            void do_run()
    … …  
    12551165                }
    12561166            }
    12571167        };
    1258 
    12591168    }
    12601169   
    12611170
    … …  
    12651174        boost::shared_ptr<detail::task_base<R> > task;
    12661175        bool future_obtained;
    12671176
    1268         packaged_task(packaged_task&);// = delete;
    1269         packaged_task& operator=(packaged_task&);// = delete;
    1270        
     1177        BOOST_MOVABLE_BUT_NOT_COPYABLE(packaged_task)
     1178        struct dummy;
    12711179    public:
    12721180        packaged_task():
    12731181            future_obtained(false)
    12741182        {}
    12751183       
    12761184        // construction and destruction
     1185#ifndef BOOST_NO_RVALUE_REFERENCES
    12771186        template <class F>
    1278         explicit packaged_task(F const& f):
    1279             task(new detail::task_object<R,F>(f)),future_obtained(false)
     1187        explicit packaged_task(F&& f):
     1188            task(new detail::task_object<R,typename boost::decay<F>::type>(boost::forward<F>(f))),
     1189            future_obtained(false)
    12801190        {}
    1281         explicit packaged_task(R(*f)()):
    1282             task(new detail::task_object<R,R(*)()>(f)),future_obtained(false)
     1191#else
     1192        template <class F>
     1193        explicit packaged_task(F f):
     1194            task(new detail::task_object<R,F>(boost::move(f))),future_obtained(false)
    12831195        {}
    12841196       
    12851197        template <class F>
    1286         explicit packaged_task(boost::detail::thread_move_t<F> f):
    1287             task(new detail::task_object<R,F>(f)),future_obtained(false)
     1198        explicit packaged_task(BOOST_RV_REF(F) f):
     1199            task(new detail::task_object<R,F>(boost::move(f))),future_obtained(false)
    12881200        {}
     1201#endif
    12891202
     1203       
    12901204//         template <class F, class Allocator>
    12911205//         explicit packaged_task(F const& f, Allocator a);
    12921206//         template <class F, class Allocator>
    … …  
    13021216        }
    13031217
    13041218        // assignment
    1305 #ifndef BOOST_NO_RVALUE_REFERENCES
    1306         packaged_task(packaged_task&& other):
     1219        packaged_task(BOOST_RV_REF(packaged_task) other):
    13071220            future_obtained(other.future_obtained)
    13081221        {
    13091222            task.swap(other.task);
    13101223            other.future_obtained=false;
    13111224        }
    1312         packaged_task& operator=(packaged_task&& other)
     1225        packaged_task& operator=(BOOST_RV_REF(packaged_task) other)
    13131226        {
    1314             packaged_task temp(static_cast<packaged_task&&>(other));
     1227            packaged_task temp(boost::move(other));
    13151228            swap(temp);
    13161229            return *this;
    13171230        }
    1318 #else
    1319         packaged_task(boost::detail::thread_move_t<packaged_task> other):
    1320             future_obtained(other->future_obtained)
    1321         {
    1322             task.swap(other->task);
    1323             other->future_obtained=false;
    1324         }
    1325         packaged_task& operator=(boost::detail::thread_move_t<packaged_task> other)
    1326         {
    1327             packaged_task temp(other);
    1328             swap(temp);
    1329             return *this;
    1330         }
    1331         operator boost::detail::thread_move_t<packaged_task>()
    1332         {
    1333             return boost::detail::thread_move_t<packaged_task>(*this);
    1334         }
    1335 #endif
    13361231
    13371232        void swap(packaged_task& other)
    13381233        {

  • boost/thread/locks.hpp 

    diff -ur boost_1_48_0/boost/thread/locks.hpp boost_1_48_0_patched/boost/thread/locks.hpp
    old new  
    66#define BOOST_THREAD_LOCKS_HPP
    77#include <boost/thread/detail/config.hpp>
    88#include <boost/thread/exceptions.hpp>
    9 #include <boost/thread/detail/move.hpp>
     9#include <boost/move/move.hpp>
    1010#include <algorithm>
    1111#include <iterator>
    1212#include <boost/thread/thread_time.hpp>
    … …  
    272272    private:
    273273        Mutex* m;
    274274        bool is_locked;
    275         unique_lock(unique_lock&);
    276275        explicit unique_lock(upgrade_lock<Mutex>&);
    277         unique_lock& operator=(unique_lock&);
    278         unique_lock& operator=(upgrade_lock<Mutex>& other);
     276        BOOST_MOVABLE_BUT_NOT_COPYABLE(unique_lock);
    279277    public:
    280278#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
    281279        unique_lock(const volatile unique_lock&);
    … …  
    311309        {
    312310            timed_lock(target_time);
    313311        }
    314 #ifndef BOOST_NO_RVALUE_REFERENCES
    315         unique_lock(unique_lock&& other):
     312
     313        unique_lock(BOOST_RV_REF(unique_lock) other):
    316314            m(other.m),is_locked(other.is_locked)
    317315        {
    318316            other.is_locked=false;
    319317            other.m=0;
    320318        }
    321         explicit unique_lock(upgrade_lock<Mutex>&& other);
    322 
    323         unique_lock<Mutex>&& move()
    324         {
    325             return static_cast<unique_lock<Mutex>&&>(*this);
    326         }
    327 
     319        explicit unique_lock(BOOST_RV_REF(upgrade_lock<Mutex>) other);
    328320
    329         unique_lock& operator=(unique_lock&& other)
     321        unique_lock& operator=(BOOST_RV_REF(unique_lock) other)
    330322        {
    331             unique_lock temp(other.move());
     323            unique_lock temp(boost::move(other));
    332324            swap(temp);
    333325            return *this;
    334326        }
    335327
    336         unique_lock& operator=(upgrade_lock<Mutex>&& other)
     328        unique_lock& operator=(BOOST_RV_REF(upgrade_lock<Mutex>) other)
    337329        {
    338             unique_lock temp(other.move());
     330            unique_lock temp(boost::move(other));
    339331            swap(temp);
    340332            return *this;
    341333        }
    342         void swap(unique_lock&& other)
     334        void swap(BOOST_RV_REF(unique_lock) other)
    343335        {
    344336            std::swap(m,other.m);
    345337            std::swap(is_locked,other.is_locked);
    346338        }
    347 #else
    348         unique_lock(detail::thread_move_t<unique_lock<Mutex> > other):
    349             m(other->m),is_locked(other->is_locked)
    350         {
    351             other->is_locked=false;
    352             other->m=0;
    353         }
    354         unique_lock(detail::thread_move_t<upgrade_lock<Mutex> > other);
    355 
    356         operator detail::thread_move_t<unique_lock<Mutex> >()
    357         {
    358             return move();
    359         }
    360 
    361         detail::thread_move_t<unique_lock<Mutex> > move()
    362         {
    363             return detail::thread_move_t<unique_lock<Mutex> >(*this);
    364         }
    365339
    366 #if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
    367         unique_lock& operator=(unique_lock<Mutex> other)
    368         {
    369             swap(other);
    370             return *this;
    371         }
    372 #else
    373         unique_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
    374         {
    375             unique_lock temp(other);
    376             swap(temp);
    377             return *this;
    378         }
    379 #endif
    380 
    381         unique_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)
    382         {
    383             unique_lock temp(other);
    384             swap(temp);
    385             return *this;
    386         }
    387         void swap(detail::thread_move_t<unique_lock<Mutex> > other)
    388         {
    389             std::swap(m,other->m);
    390             std::swap(is_locked,other->is_locked);
    391         }
    392 #endif
    393340        void swap(unique_lock& other)
    394341        {
    395342            std::swap(m,other.m);
    … …  
    479426        friend class upgrade_lock<Mutex>;
    480427    };
    481428
    482 #ifndef BOOST_NO_RVALUE_REFERENCES
    483     template<typename Mutex>
    484     void swap(unique_lock<Mutex>&& lhs,unique_lock<Mutex>&& rhs)
    485     {
    486         lhs.swap(rhs);
    487     }
    488429
    489430    template<typename Mutex>
    490     inline upgrade_lock<Mutex>&& move(upgrade_lock<Mutex>&& ul)
     431    void swap(BOOST_RV_REF(unique_lock<Mutex>) lhs, BOOST_RV_REF(unique_lock<Mutex>) rhs)
    491432    {
    492         return static_cast<upgrade_lock<Mutex>&&>(ul);
     433        lhs.swap(rhs);
    493434    }
    494435
    495436    template<typename Mutex>
    496     inline upgrade_lock<Mutex>&& move(upgrade_lock<Mutex>& ul)
    497     {
    498         return static_cast<upgrade_lock<Mutex>&&>(ul);
    499     }
    500 #endif
    501     template<typename Mutex>
    502437    void swap(unique_lock<Mutex>& lhs,unique_lock<Mutex>& rhs)
    503438    {
    504439        lhs.swap(rhs);
    505440    }
    506441
    507 #ifndef BOOST_NO_RVALUE_REFERENCES
    508     template<typename Mutex>
    509     inline unique_lock<Mutex>&& move(unique_lock<Mutex>&& ul)
    510     {
    511         return static_cast<unique_lock<Mutex>&&>(ul);
    512     }
    513 
    514     template<typename Mutex>
    515     inline unique_lock<Mutex>&& move(unique_lock<Mutex>& ul)
    516     {
    517         return static_cast<unique_lock<Mutex>&&>(ul);
    518     }
    519 #endif
    520 
    521442    template<typename Mutex>
    522443    class shared_lock
    523444    {
    … …  
    525446        Mutex* m;
    526447        bool is_locked;
    527448    private:
    528         explicit shared_lock(shared_lock&);
    529         shared_lock& operator=(shared_lock&);
     449        BOOST_MOVABLE_BUT_NOT_COPYABLE(shared_lock)
    530450    public:
    531451        shared_lock():
    532452            m(0),is_locked(false)
    … …  
    554474            timed_lock(target_time);
    555475        }
    556476
    557         shared_lock(detail::thread_move_t<shared_lock<Mutex> > other):
     477        shared_lock(BOOST_RV_REF(shared_lock<Mutex>) other):
    558478            m(other->m),is_locked(other->is_locked)
    559479        {
    560480            other->is_locked=false;
    561481            other->m=0;
    562482        }
    563483
    564         shared_lock(detail::thread_move_t<unique_lock<Mutex> > other):
     484        shared_lock(BOOST_RV_REF(unique_lock<Mutex>) other):
    565485            m(other->m),is_locked(other->is_locked)
    566486        {
    567487            if(is_locked)
    … …  
    572492            other->m=0;
    573493        }
    574494
    575         shared_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):
     495        shared_lock(BOOST_RV_REF(upgrade_lock<Mutex>) other):
    576496            m(other->m),is_locked(other->is_locked)
    577497        {
    578498            if(is_locked)
    … …  
    583503            other->m=0;
    584504        }
    585505
    586         operator detail::thread_move_t<shared_lock<Mutex> >()
    587         {
    588             return move();
    589         }
    590 
    591         detail::thread_move_t<shared_lock<Mutex> > move()
    592         {
    593             return detail::thread_move_t<shared_lock<Mutex> >(*this);
    594         }
    595 
    596 
    597         shared_lock& operator=(detail::thread_move_t<shared_lock<Mutex> > other)
     506        shared_lock& operator=(BOOST_RV_REF(shared_lock<Mutex>) other)
    598507        {
    599508            shared_lock temp(other);
    600509            swap(temp);
    601510            return *this;
    602511        }
    603512
    604         shared_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
     513        shared_lock& operator=(BOOST_RV_REF(unique_lock<Mutex>) other)
    605514        {
    606515            shared_lock temp(other);
    607516            swap(temp);
    608517            return *this;
    609518        }
    610519
    611         shared_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)
     520        shared_lock& operator=(BOOST_RV_REF(upgrade_lock<Mutex>) other)
    612521        {
    613522            shared_lock temp(other);
    614523            swap(temp);
    615524            return *this;
    616525        }
    617526
    618 #ifndef BOOST_NO_RVALUE_REFERENCES
    619         void swap(shared_lock&& other)
     527        void swap(BOOST_RV_REF(shared_lock) other)
    620528        {
    621529            std::swap(m,other.m);
    622530            std::swap(is_locked,other.is_locked);
    623531        }
    624 #else
    625         void swap(boost::detail::thread_move_t<shared_lock<Mutex> > other)
    626         {
    627             std::swap(m,other->m);
    628             std::swap(is_locked,other->is_locked);
    629         }
    630 #endif
     532
    631533        void swap(shared_lock& other)
    632534        {
    633535            std::swap(m,other.m);
    … …  
    709611
    710612    };
    711613
    712 #ifndef BOOST_NO_RVALUE_REFERENCES
    713     template<typename Mutex>
    714     void swap(shared_lock<Mutex>&& lhs,shared_lock<Mutex>&& rhs)
    715     {
    716         lhs.swap(rhs);
    717     }
    718 #else
    719614    template<typename Mutex>
    720     void swap(shared_lock<Mutex>& lhs,shared_lock<Mutex>& rhs)
     615    void swap(BOOST_RV_REF(shared_lock<Mutex>) lhs,BOOST_RV_REF(shared_lock<Mutex>) rhs)
    721616    {
    722617        lhs.swap(rhs);
    723618    }
    724 #endif
    725619
    726620    template<typename Mutex>
    727621    class upgrade_lock
    … …  
    730624        Mutex* m;
    731625        bool is_locked;
    732626    private:
    733         explicit upgrade_lock(upgrade_lock&);
    734         upgrade_lock& operator=(upgrade_lock&);
     627        BOOST_MOVABLE_BUT_NOT_COPYABLE(upgrade_lock)
    735628    public:
    736629        upgrade_lock():
    737630            m(0),is_locked(false)
    … …  
    753646        {
    754647            try_lock();
    755648        }
    756 #ifdef BOOST_HAS_RVALUE_REFS
    757         upgrade_lock(upgrade_lock<Mutex>&& other):
     649
     650        upgrade_lock(BOOST_RV_REF(upgrade_lock) other):
    758651            m(other.m),is_locked(other.is_locked)
    759652        {
    760653            other.is_locked=false;
    761654            other.m=0;
    762655        }
    763656
    764         upgrade_lock(unique_lock<Mutex>&& other):
     657        upgrade_lock(BOOST_RV_REF(unique_lock<Mutex>) other):
    765658            m(other.m),is_locked(other.is_locked)
    766659        {
    767660            if(is_locked)
    … …  
    772665            other.m=0;
    773666        }
    774667
    775         upgrade_lock& operator=(upgrade_lock<Mutex>&& other)
     668        upgrade_lock& operator=(BOOST_RV_REF(upgrade_lock) other)
    776669        {
    777             upgrade_lock temp(static_cast<upgrade_lock<Mutex>&&>(other));
     670            upgrade_lock temp(boost::move(other));
    778671            swap(temp);
    779672            return *this;
    780673        }
    781674
    782         upgrade_lock& operator=(unique_lock<Mutex>&& other)
     675        upgrade_lock& operator=(BOOST_RV_REF(unique_lock<Mutex>) other)
    783676        {
    784             upgrade_lock temp(static_cast<unique_lock<Mutex>&&>(other));
     677            upgrade_lock temp(boost::move(other));
    785678            swap(temp);
    786679            return *this;
    787680        }
    788 #else
    789         upgrade_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):
    790             m(other->m),is_locked(other->is_locked)
    791         {
    792             other->is_locked=false;
    793             other->m=0;
    794         }
    795 
    796         upgrade_lock(detail::thread_move_t<unique_lock<Mutex> > other):
    797             m(other->m),is_locked(other->is_locked)
    798         {
    799             if(is_locked)
    800             {
    801                 m->unlock_and_lock_upgrade();
    802             }
    803             other->is_locked=false;
    804             other->m=0;
    805         }
    806 
    807         operator detail::thread_move_t<upgrade_lock<Mutex> >()
    808         {
    809             return move();
    810         }
    811 
    812         detail::thread_move_t<upgrade_lock<Mutex> > move()
    813         {
    814             return detail::thread_move_t<upgrade_lock<Mutex> >(*this);
    815         }
    816 
    817 
    818         upgrade_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)
    819         {
    820             upgrade_lock temp(other);
    821             swap(temp);
    822             return *this;
    823         }
    824 
    825         upgrade_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
    826         {
    827             upgrade_lock temp(other);
    828             swap(temp);
    829             return *this;
    830         }
    831 #endif
    832681
    833682        void swap(upgrade_lock& other)
    834683        {
    … …  
    888737        friend class unique_lock<Mutex>;
    889738    };
    890739
    891 
    892 #ifndef BOOST_NO_RVALUE_REFERENCES
    893740    template<typename Mutex>
    894     unique_lock<Mutex>::unique_lock(upgrade_lock<Mutex>&& other):
     741    unique_lock<Mutex>::unique_lock(BOOST_RV_REF(upgrade_lock<Mutex>) other):
    895742        m(other.m),is_locked(other.is_locked)
    896743    {
    897744        other.is_locked=false;
    … …  
    900747            m->unlock_upgrade_and_lock();
    901748        }
    902749    }
    903 #else
    904     template<typename Mutex>
    905     unique_lock<Mutex>::unique_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):
    906         m(other->m),is_locked(other->is_locked)
    907     {
    908         other->is_locked=false;
    909         if(is_locked)
    910         {
    911             m->unlock_upgrade_and_lock();
    912         }
    913     }
    914 #endif
     750
    915751    template <class Mutex>
    916752    class upgrade_to_unique_lock
    917753    {
    … …  
    919755        upgrade_lock<Mutex>* source;
    920756        unique_lock<Mutex> exclusive;
    921757
    922         explicit upgrade_to_unique_lock(upgrade_to_unique_lock&);
    923         upgrade_to_unique_lock& operator=(upgrade_to_unique_lock&);
     758        BOOST_MOVABLE_BUT_NOT_COPYABLE(upgrade_to_unique_lock)
    924759    public:
    925760        explicit upgrade_to_unique_lock(upgrade_lock<Mutex>& m_):
    926             source(&m_),exclusive(move(*source))
     761            source(&m_),exclusive(boost::move(*source))
    927762        {}
    928763        ~upgrade_to_unique_lock()
    929764        {
    930765            if(source)
    931766            {
    932                 *source=move(exclusive);
     767                *source=boost::move(exclusive);
    933768            }
    934769        }
    935770
    936 #ifdef BOOST_HAS_RVALUE_REFS
    937         upgrade_to_unique_lock(upgrade_to_unique_lock<Mutex>&& other):
    938             source(other.source),exclusive(move(other.exclusive))
     771        upgrade_to_unique_lock(BOOST_RV_REF(upgrade_to_unique_lock<Mutex>) other):
     772            source(other.source),exclusive(boost::move(other.exclusive))
    939773        {
    940774            other.source=0;
    941775        }
    942776       
    943         upgrade_to_unique_lock& operator=(upgrade_to_unique_lock<Mutex>&& other)
    944         {
    945             upgrade_to_unique_lock temp(other);
    946             swap(temp);
    947             return *this;
    948         }
    949 #else
    950         upgrade_to_unique_lock(detail::thread_move_t<upgrade_to_unique_lock<Mutex> > other):
    951             source(other->source),exclusive(move(other->exclusive))
    952         {
    953             other->source=0;
    954         }
    955        
    956         upgrade_to_unique_lock& operator=(detail::thread_move_t<upgrade_to_unique_lock<Mutex> > other)
     777        upgrade_to_unique_lock& operator=(BOOST_RV_REF(upgrade_to_unique_lock<Mutex>) other)
    957778        {
    958779            upgrade_to_unique_lock temp(other);
    959780            swap(temp);
    960781            return *this;
    961782        }
    962 #endif
     783
    963784        void swap(upgrade_to_unique_lock& other)
    964785        {
    965786            std::swap(source,other.source);
    … …  
    986807        class try_lock_wrapper:
    987808            private unique_lock<Mutex>
    988809        {
     810            BOOST_MOVABLE_BUT_NOT_COPYABLE(try_lock_wrapper)
    989811            typedef unique_lock<Mutex> base;
    990812        public:
    991813            try_lock_wrapper()
    … …  
    1004826            try_lock_wrapper(Mutex& m_,try_to_lock_t):
    1005827                base(m_,try_to_lock)
    1006828            {}
    1007 #ifndef BOOST_NO_RVALUE_REFERENCES
    1008             try_lock_wrapper(try_lock_wrapper&& other):
    1009                 base(other.move())
    1010             {}
    1011829
    1012             try_lock_wrapper&& move()
    1013             {
    1014                 return static_cast<try_lock_wrapper&&>(*this);
    1015             }
    1016 
    1017             try_lock_wrapper& operator=(try_lock_wrapper<Mutex>&& other)
     830            try_lock_wrapper(BOOST_RV_REF(try_lock_wrapper) other):
     831                base(boost::move(static_cast<base&>(other)))
     832            {}
     833           
     834            try_lock_wrapper& operator=(BOOST_RV_REF(try_lock_wrapper<Mutex>) other)
    1018835            {
    1019                 try_lock_wrapper temp(other.move());
     836                try_lock_wrapper temp(boost::move(other));
    1020837                swap(temp);
    1021838                return *this;
    1022839            }
    1023840
    1024             void swap(try_lock_wrapper&& other)
     841            void swap(BOOST_RV_REF(try_lock_wrapper) other)
    1025842            {
    1026843                base::swap(other);
    1027844            }
    1028 #else
    1029             try_lock_wrapper(detail::thread_move_t<try_lock_wrapper<Mutex> > other):
    1030                 base(detail::thread_move_t<base>(*other))
    1031             {}
    1032 
    1033             operator detail::thread_move_t<try_lock_wrapper<Mutex> >()
    1034             {
    1035                 return move();
    1036             }
    1037 
    1038             detail::thread_move_t<try_lock_wrapper<Mutex> > move()
    1039             {
    1040                 return detail::thread_move_t<try_lock_wrapper<Mutex> >(*this);
    1041             }
    1042 
    1043             try_lock_wrapper& operator=(detail::thread_move_t<try_lock_wrapper<Mutex> > other)
    1044             {
    1045                 try_lock_wrapper temp(other);
    1046                 swap(temp);
    1047                 return *this;
    1048             }
    1049845
    1050             void swap(detail::thread_move_t<try_lock_wrapper<Mutex> > other)
    1051             {
    1052                 base::swap(*other);
    1053             }
    1054 #endif
    1055846            void swap(try_lock_wrapper& other)
    1056847            {
    1057848                base::swap(other);
    … …  
    1092883            }
    1093884        };
    1094885
    1095 #ifndef BOOST_NO_RVALUE_REFERENCES
    1096886        template<typename Mutex>
    1097         void swap(try_lock_wrapper<Mutex>&& lhs,try_lock_wrapper<Mutex>&& rhs)
     887        void swap(BOOST_RV_REF(try_lock_wrapper<Mutex>) lhs,BOOST_RV_REF(try_lock_wrapper<Mutex>) rhs)
    1098888        {
    1099889            lhs.swap(rhs);
    1100890        }
    1101 #else
    1102         template<typename Mutex>
    1103         void swap(try_lock_wrapper<Mutex>& lhs,try_lock_wrapper<Mutex>& rhs)
    1104         {
    1105             lhs.swap(rhs);
    1106         }
    1107 #endif
    1108891       
    1109892        template<typename MutexType1,typename MutexType2>
    1110893        unsigned try_lock_internal(MutexType1& m1,MutexType2& m2)