When users define the BOOST_RV_REF
overload of a copy constructor/assignment, in C++0x compilers it is expanded
to a rvalue reference (T&&)
overload and in C++03 compilers it is expanded to a ::boost::rv<T>& overload:

#defineBOOST_RV_REF(TYPE)::boost::rv<TYPE>&\

When users define the BOOST_COPY_ASSIGN_REF
overload, it is expanded to a usual copy assignment (constT&)
overload in C++0x compilers and to a const::boost::rv&
overload in C++03 compilers:

#defineBOOST_COPY_ASSIGN_REF(TYPE)const::boost::rv<TYPE>&

As seen, in Boost.Move generates efficient
and clean code for C++0x move semantics, without modifying any resolution overload.
For C++03 compilers when overload resolution is performed these are the bindings:

a) non-const rvalues (e.g.: temporaries), bind to ::boost::rv<TYPE>&

b) const rvalue and lvalues, bind to const::boost::rv<TYPE>&

c) non-const lvalues (e.g. non-const references) bind to TYPE&

The library does not define the equivalent of BOOST_COPY_ASSIGN_REF
for copy construction (say, BOOST_COPY_CTOR_REF)
because nearly all modern compilers implement RVO and this is much more efficient
than any move emulation. move
just casts TYPE&
into ::boost::rv<TYPE>&.

Here's an example that demostrates how different rlvalue objects bind to ::boost::rv references in the presence of three overloads
and the conversion operators in C++03 compilers: