[Boost-commit] svn:boost r85408 - in branches/release: boost/variant boost/variant/detail libs/variant/test

Subject: [Boost-commit] svn:boost r85408 - in branches/release: boost/variant boost/variant/detail libs/variant/test
From: antoshkka_at_[hidden]
Date: 2013-08-20 05:03:29

Author: apolukhin
Date: 2013-08-20 05:03:29 EDT (Tue, 20 Aug 2013)
New Revision: 85408
URL: http://svn.boost.org/trac/boost/changeset/85408

Log:
Merge from trunk:
* Fix issue with const rvalue references in Boost.Variant (fixes #8988)
* Get rid of Boost.Variant hand written non-usable move emulation and use Boost.Move instead(refs #7601). This does not mean that Boost.Variant supports move emulation now, but removes duplicate/non-working code and makes sure that Boost.Variant is able to work with boost::move

Text files modified: 
   branches/release/boost/variant/detail/move.hpp     |    92 ---------------------------------       
   branches/release/boost/variant/variant.hpp         |     6 +                                       
   branches/release/libs/variant/test/rvalue_test.cpp |   107 ++++++++++++++++++++++++++++----------- 
   3 files changed, 81 insertions(+), 124 deletions(-)

Modified: branches/release/boost/variant/detail/move.hpp
==============================================================================
--- branches/release/boost/variant/detail/move.hpp	Tue Aug 20 04:57:49 2013	(r85407)
+++ branches/release/boost/variant/detail/move.hpp	2013-08-20 05:03:29 EDT (Tue, 20 Aug 2013)	(r85408)
@@ -24,100 +24,12 @@
 
 #include "boost/config.hpp"
 #include "boost/detail/workaround.hpp"
-#include "boost/mpl/if.hpp"
-#include "boost/type_traits/is_base_and_derived.hpp"
+#include "boost/move/move.hpp"
 
 namespace boost {
 namespace detail { namespace variant {
 
-//////////////////////////////////////////////////////////////////////////
-// forward declares
-//
-// NOTE: Incomplete until (if?) Boost.Move becomes part of Boost.
-//
-template <typename Deriving> class moveable;
-template <typename T>        class move_source;
-template <typename T>        class move_return;
-
-namespace detail {
-
-// (detail) moveable_tag
-//
-// Concrete type from which moveable<T> derives.
-//
-// TODO: Move into moveable_fwd.hpp and define has_move_constructor.
-//
-template <typename Deriving>
-struct moveable_tag
-{
-};
-
-} // namespace detail
-
-//////////////////////////////////////////////////////////////////////////
-// function template move
-//
-// Takes a T& and returns, if T derives moveable<T>, a move_source<T> for
-// the object; else, returns the T&.
-//
-
-namespace detail {
-
-// (detail) class template move_type
-//
-// Metafunction that, given moveable T, provides move_source<T>, else T&.
-//
-template <typename T>
-struct move_type
-{
-public: // metafunction result
-
-    typedef typename mpl::if_<
-          is_base_and_derived<detail::moveable_tag<T>, T>
-        , move_source<T>
-        , T&
-        >::type type;
-
-};
-
-} // namespace detail
-
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-template <typename T>
-inline
-    typename detail::move_type<T>::type
-move(T& source)
-{
-    typedef typename detail::move_type<T>::type
-        move_t;
-
-    return move_t(source);
-}
-
-#else
-
-using std::move;
-
-#endif
-
-//////////////////////////////////////////////////////////////////////////
-// class template return_t
-//
-// Metafunction that, given moveable T, provides move_return<T>, else T.
-//
-template <typename T>
-struct return_t
-{
-public: // metafunction result
-
-    typedef typename mpl::if_<
-          is_base_and_derived<moveable<T>, T>
-        , move_return<T>
-        , T
-        >::type type;
-
-};
+using boost::move;
 
 //////////////////////////////////////////////////////////////////////////
 // function template move_swap

Modified: branches/release/boost/variant/variant.hpp
==============================================================================
--- branches/release/boost/variant/variant.hpp	Tue Aug 20 04:57:49 2013	(r85407)
+++ branches/release/boost/variant/variant.hpp	2013-08-20 05:03:29 EDT (Tue, 20 Aug 2013)	(r85408)
@@ -1776,7 +1776,8 @@
     
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
     template <class T>
-    variant(T&& operand, typename boost::enable_if<boost::is_rvalue_reference<T&&> >::type* = 0)
+    variant(T&& operand, typename boost::enable_if<boost::is_rvalue_reference<T&&> >::type* = 0, 
+        typename boost::disable_if<boost::is_const<T> >::type* = 0)
     {
         convert_construct( detail::variant::move(operand), 1L);
     }
@@ -2187,7 +2188,8 @@
 
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
     template <class T>
-    typename boost::enable_if<boost::is_rvalue_reference<T&&>, variant& >::type operator=(T&& rhs)
+    typename boost::enable_if_c<boost::is_rvalue_reference<T&&>::value && !boost::is_const<T>::value, variant& >::type 
+        operator=(T&& rhs)
     {
         move_assign( detail::variant::move(rhs) );
         return *this;

Modified: branches/release/libs/variant/test/rvalue_test.cpp
==============================================================================
--- branches/release/libs/variant/test/rvalue_test.cpp	Tue Aug 20 04:57:49 2013	(r85407)
+++ branches/release/libs/variant/test/rvalue_test.cpp	2013-08-20 05:03:29 EDT (Tue, 20 Aug 2013)	(r85408)
@@ -15,13 +15,56 @@
 #include "boost/variant.hpp"
 #include "boost/type_traits/is_nothrow_move_assignable.hpp"
 
-// This test requires rvalue references support
+// Most part of tests from this file require rvalue references support
+
+
+class move_copy_conting_class {
+public:
+    static unsigned int moves_count;
+    static unsigned int copy_count;
+
+    move_copy_conting_class(){}
+    move_copy_conting_class(BOOST_RV_REF(move_copy_conting_class) ) {
+        ++ moves_count;
+    }
+
+    move_copy_conting_class& operator=(BOOST_RV_REF(move_copy_conting_class) ) {
+        ++ moves_count;
+        return *this;
+    }
+
+    move_copy_conting_class(const move_copy_conting_class&) {
+        ++ copy_count;
+    }
+    move_copy_conting_class& operator=(BOOST_COPY_ASSIGN_REF(move_copy_conting_class) ) {
+        ++ copy_count;
+        return *this;
+    }
+};
+
+unsigned int move_copy_conting_class::moves_count = 0;
+unsigned int move_copy_conting_class::copy_count = 0;
 
 #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
 
 void run()
 {
-    BOOST_CHECK(true);
+    // Making sure that internals of Boost.Move do not interfere with
+    // internals of Boost.Variant and in case of C++03 or C++98 compilation 
+    // is still possible.
+    typedef boost::variant<int, move_copy_conting_class> variant_I_type;
+    variant_I_type v1, v2;
+    v1 = move_copy_conting_class();
+    v2 = v1; 
+    v2 = boost::move(v1);
+    v1.swap(v2);
+
+    move_copy_conting_class val;
+    v2 = boost::move(val);
+    v2 = 10;
+
+    variant_I_type v3(boost::move(val));
+    variant_I_type v4(boost::move(v1));
 }
 
 void run1()
@@ -39,34 +82,15 @@
     BOOST_CHECK(true);
 }
 
-#else 
 
-class move_copy_conting_class {
-public:
-    static unsigned int moves_count;
-    static unsigned int copy_count;
+void run_const_rvalues()
+{
+    BOOST_CHECK(true);
+}
 
-    move_copy_conting_class(){}
-    move_copy_conting_class(move_copy_conting_class&&) {
-        ++ moves_count;
-    }
 
-    move_copy_conting_class& operator=(move_copy_conting_class&&) {
-        ++ moves_count;
-        return *this;
-    }
-
-    move_copy_conting_class(const move_copy_conting_class&) {
-        ++ copy_count;
-    }
-    move_copy_conting_class& operator=(const move_copy_conting_class&) {
-        ++ copy_count;
-        return *this;
-    }
-};
+#else 
 
-unsigned int move_copy_conting_class::moves_count = 0;
-unsigned int move_copy_conting_class::copy_count = 0;
 
 void run()
 {
@@ -92,7 +116,7 @@
 
     move_copy_conting_class::moves_count = 0;
     move_copy_conting_class::copy_count = 0;
-    v2 = static_cast<variant_I_type&&>(v1);
+    v2 = boost::move(v1);
     // Assuring that `move_copy_conting_class` in v1 was moved at least once and was not copied
     BOOST_CHECK(move_copy_conting_class::moves_count != 0);
     BOOST_CHECK(move_copy_conting_class::copy_count == 0);
@@ -100,7 +124,7 @@
     v1 = move_copy_conting_class();
     move_copy_conting_class::moves_count = 0;
     move_copy_conting_class::copy_count = 0;
-    v2 = static_cast<variant_I_type&&>(v1);
+    v2 = boost::move(v1);
     // Assuring that `move_copy_conting_class` in v1 was moved at least once and was not copied
     BOOST_CHECK(move_copy_conting_class::moves_count != 0);
     BOOST_CHECK(move_copy_conting_class::copy_count == 0);
@@ -116,19 +140,19 @@
     variant_II_type v3;
     move_copy_conting_class::moves_count = 0;
     move_copy_conting_class::copy_count = 0;
-    v1 = static_cast<variant_II_type&&>(v3);
+    v1 = boost::move(v3);
     // Assuring that `move_copy_conting_class` in v3 was moved at least once (v1 and v3 have different types)
     BOOST_CHECK(move_copy_conting_class::moves_count != 0);
 
     move_copy_conting_class::moves_count = 0;
     move_copy_conting_class::copy_count = 0;
-    v2 = static_cast<variant_I_type&&>(v1);
+    v2 = boost::move(v1);
     // Assuring that `move_copy_conting_class` in v1 was moved at least once (v1 and v3 have different types)
     BOOST_CHECK(move_copy_conting_class::moves_count != 0);
 
     move_copy_conting_class::moves_count = 0;
     move_copy_conting_class::copy_count = 0;
-    variant_I_type v5(static_cast<variant_I_type&&>(v1));
+    variant_I_type v5(boost::move(v1));
     // Assuring that `move_copy_conting_class` in v1 was moved at least once and was not copied
     BOOST_CHECK(move_copy_conting_class::moves_count != 0);
     BOOST_CHECK(move_copy_conting_class::copy_count == 0);
@@ -148,7 +172,7 @@
 
     move_copy_conting_class c1;
     typedef boost::variant<int, move_copy_conting_class> variant_I_type;
-    variant_I_type v1(static_cast<move_copy_conting_class&&>(c1));
+    variant_I_type v1(boost::move(c1));
     
     // Assuring that `move_copy_conting_class` was not copyied
     BOOST_CHECK(move_copy_conting_class::copy_count == 0);
@@ -194,6 +218,24 @@
 #endif
 }
 
+inline const std::string get_string() { return "test"; } 
+inline const boost::variant<int, std::string> get_variant() { return std::string("test"); } 
+inline const boost::variant<std::string, int> get_variant2() { return std::string("test"); } 
+
+void run_const_rvalues()
+{
+    typedef boost::variant<int, std::string> variant_t;
+    const variant_t v1(get_string());
+    const variant_t v2(get_variant());
+    const variant_t v3(get_variant2());
+    
+    variant_t v4, v5, v6, v7;
+    v4 = get_string();
+    v5 = get_variant();
+    v6 = get_variant2();
+    v7 = boost::move(v1);
+}
+
 #endif
 
 struct nothrow_copyable_throw_movable {
@@ -221,5 +263,6 @@
    run_move_only();
    run_moves_are_noexcept();
    run_tricky_compilation_test();
+   run_const_rvalues();
    return 0;
 }