import quincy beta 17.1.0

[ceph.git] / ceph / src / boost / boost / spirit / home / x3 / support / traits / move_to.hpp

diff --git a/ceph/src/boost/boost/spirit/home/x3/support/traits/move_to.hpp b/ceph/src/boost/boost/spirit/home/x3/support/traits/move_to.hpp
index 54e6ce4ad06929817ca8c6e21734314ef66086fc..1cb5c1a2663e23cc860e2c5cc3c0f903ae7565f4 100644 (file)
--- a/ceph/src/boost/boost/spirit/home/x3/support/traits/move_to.hpp
+++ b/ceph/src/boost/boost/spirit/home/x3/support/traits/move_to.hpp
@@ -12,6 +12,8 @@
 #include <boost/spirit/home/x3/support/traits/attribute_category.hpp>
 #include <boost/spirit/home/x3/support/traits/tuple_traits.hpp>
 #include <boost/spirit/home/x3/support/traits/variant_has_substitute.hpp>
+
+#include <boost/assert.hpp>
 #include <boost/fusion/include/is_sequence.hpp>
 #include <boost/fusion/include/front.hpp>
 #include <boost/fusion/include/move.hpp>
@@ -51,37 +53,37 @@ namespace boost { namespace spirit { namespace x3 { namespace traits
     {
         template <typename Source, typename Dest>
         inline void
-        move_to(Source&&, Dest&, unused_attribute) {}
+        move_to(Source&, Dest&, unused_attribute) {}
         
         template <typename Source, typename Dest>
         inline void
-        move_to_plain(Source&& src, Dest& dest, mpl::false_) // src is not a single-element tuple
+        move_to_plain(Source& src, Dest& dest, mpl::false_) // src is not a single-element tuple
         {
             dest = std::move(src);
         }
         
         template <typename Source, typename Dest>
         inline void
-        move_to_plain(Source&& src, Dest& dest, mpl::true_) // src is a single-element tuple
+        move_to_plain(Source& src, Dest& dest, mpl::true_) // src is a single-element tuple
         {
             dest = std::move(fusion::front(src));
         }
 
         template <typename Source, typename Dest>
         inline void
-        move_to(Source&& src, Dest& dest, plain_attribute)
+        move_to(Source& src, Dest& dest, plain_attribute)
         {
             typename mpl::and_<
                 fusion::traits::is_sequence<Source>,
                 is_size_one_sequence<Source> >
             is_single_element_sequence;
         
-            move_to_plain(std::forward<Source>(src), dest, is_single_element_sequence);
+            move_to_plain(src, dest, is_single_element_sequence);
         }
 
         template <typename Source, typename Dest>
         inline typename enable_if<is_container<Source>>::type
-        move_to(Source&& src, Dest& dest, container_attribute)
+        move_to(Source& src, Dest& dest, container_attribute)
         {
             traits::move_to(src.begin(), src.end(), dest);
         }
@@ -92,30 +94,30 @@ namespace boost { namespace spirit { namespace x3 { namespace traits
                 is_same_size_sequence<Dest, Source>,
                 mpl::not_<is_size_one_sequence<Dest> > >
         >::type
-        move_to(Source&& src, Dest& dest, tuple_attribute)
+        move_to(Source& src, Dest& dest, tuple_attribute)
         {
-            fusion::move(std::forward<Source>(src), dest);
+            fusion::move(std::move(src), dest);
         }
 
         template <typename Source, typename Dest>
         inline typename enable_if<
             is_size_one_sequence<Dest>
         >::type
-        move_to(Source&& src, Dest& dest, tuple_attribute)
+        move_to(Source& src, Dest& dest, tuple_attribute)
         {
-            traits::move_to(std::forward<Source>(src), fusion::front(dest));
+            traits::move_to(src, fusion::front(dest));
         }
 
         template <typename Source, typename Dest>
         inline void
-        move_to(Source&& src, Dest& dest, variant_attribute, mpl::false_)
+        move_to(Source& src, Dest& dest, variant_attribute, mpl::false_)
         {
             dest = std::move(src);
         }
         
         template <typename Source, typename Dest>
         inline void
-        move_to_variant_from_single_element_sequence(Source&& src, Dest& dest, mpl::false_)
+        move_to_variant_from_single_element_sequence(Source& src, Dest& dest, mpl::false_)
         {
             // dest is a variant, src is a single element fusion sequence that the variant
             // cannot directly hold. We'll try to unwrap the single element fusion sequence.
@@ -129,7 +131,7 @@ namespace boost { namespace spirit { namespace x3 { namespace traits
         
         template <typename Source, typename Dest>
         inline void
-        move_to_variant_from_single_element_sequence(Source&& src, Dest& dest, mpl::true_)
+        move_to_variant_from_single_element_sequence(Source& src, Dest& dest, mpl::true_)
         {
             // dest is a variant, src is a single element fusion sequence that the variant
             // *can* directly hold.
@@ -138,21 +140,21 @@ namespace boost { namespace spirit { namespace x3 { namespace traits
 
         template <typename Source, typename Dest>
         inline void
-        move_to(Source&& src, Dest& dest, variant_attribute, mpl::true_)
+        move_to(Source& src, Dest& dest, variant_attribute, mpl::true_)
         {
             move_to_variant_from_single_element_sequence(src, dest, variant_has_substitute<Dest, Source>());
         }
 
         template <typename Source, typename Dest>
         inline void
-        move_to(Source&& src, Dest& dest, variant_attribute tag)
+        move_to(Source& src, Dest& dest, variant_attribute tag)
         {
             move_to(src, dest, tag, is_size_one_sequence<Source>());
         }
 
         template <typename Source, typename Dest>
         inline void
-        move_to(Source&& src, Dest& dest, optional_attribute)
+        move_to(Source& src, Dest& dest, optional_attribute)
         {
             dest = std::move(src);
         }
@@ -188,39 +190,31 @@ namespace boost { namespace spirit { namespace x3 { namespace traits
         }
     }
 
-    template <typename Source, typename Dest>
-    inline void move_to(boost::optional<Source>&& src, Dest& dest)
-    {
-        if (src) detail::move_to(std::move(*src), dest
-          , typename attribute_category<Dest>::type());
-    }
-
     template <typename Source, typename Dest>
     inline void move_to(Source&& src, Dest& dest)
     {
-        detail::move_to(std::move(src), dest
-          , typename attribute_category<Dest>::type());
+        detail::move_to(src, dest, typename attribute_category<Dest>::type());
     }
 
     template <typename T>
     inline void move_to(T& src, T& dest)
     {
-        if (boost::addressof(src) != boost::addressof(dest))
-            dest = std::move(src);
+        BOOST_ASSERT(boost::addressof(src) != boost::addressof(dest));
+        dest = std::move(src);
     }
 
     template <typename T>
     inline void move_to(T const& src, T& dest)
     {
-        if (boost::addressof(src) != boost::addressof(dest))
-            dest = std::move(src);
+        BOOST_ASSERT(boost::addressof(src) != boost::addressof(dest));
+        dest = src;
     }
 
     template <typename T>
     inline void move_to(T&& src, T& dest)
     {
-        if (boost::addressof(src) != boost::addressof(dest))
-            dest = std::move(src);
+        BOOST_ASSERT(boost::addressof(src) != boost::addressof(dest));
+        dest = std::move(src);
     }
 
     template <typename Iterator, typename Dest>