X-Git-Url: https://git.donarmstrong.com/?p=rsem.git;a=blobdiff_plain;f=boost%2Ffusion%2Fcontainer%2Fvector%2Fdetail%2Fvector_n.hpp;h=1354ff41e0239458efea521230171979323c2c8e;hp=ea314ac28e16a0d6a0c4f883325347c90ec57ea6;hb=2d71eb92104693ca9baa5a2e1c23eeca776d8fd3;hpb=da57529b92adbb7ae74a89861cb39fb35ac7c62d

diff --git a/boost/fusion/container/vector/detail/vector_n.hpp b/boost/fusion/container/vector/detail/vector_n.hpp
index ea314ac..1354ff4 100644
--- a/boost/fusion/container/vector/detail/vector_n.hpp
+++ b/boost/fusion/container/vector/detail/vector_n.hpp
@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2001-2006 Joel de Guzman
+    Copyright (c) 2001-2011 Joel de Guzman
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -9,24 +9,44 @@
 #if !defined(FUSION_MACRO_05042005)
 #define FUSION_MACRO_05042005
 
-#define FUSION_MEMBER_DEFAULT_INIT(z, n, _)     m##n()
-#define FUSION_MEMBER_INIT(z, n, _)             m##n(_##n)
-#define FUSION_COPY_INIT(z, n, _)               m##n(other.m##n)
-#define FUSION_MEMBER_DECL(z, n, _)             T##n m##n;
+#define FUSION_VECTOR_CTOR_DEFAULT_INIT(z, n, _)                                \
+    m##n()
 
-#define FUSION_MEMBER_ASSIGN(z, n, _)                                           \
+#define FUSION_VECTOR_CTOR_INIT(z, n, _)                                        \
+    m##n(_##n)
+
+#define FUSION_VECTOR_MEMBER_CTOR_INIT(z, n, _)                                 \
+    m##n(other.m##n)
+
+#define FUSION_VECTOR_CTOR_FORWARD(z, n, _)                                     \
+   m##n(std::forward<T##n>(other.m##n))
+
+#define FUSION_VECTOR_CTOR_ARG_FWD(z, n, _)                                     \
+   m##n(std::forward<U##n>(_##n))
+
+#define FUSION_VECTOR_MEMBER_DECL(z, n, _)                                      \
+    T##n m##n;
+
+#define FUSION_VECTOR_MEMBER_FORWARD(z, n, _)                                   \
+   std::forward<U##n>(_##n)
+
+#define FUSION_VECTOR_MEMBER_ASSIGN(z, n, _)                                    \
     this->BOOST_PP_CAT(m, n) = vec.BOOST_PP_CAT(m, n);
 
-#define FUSION_DEREF_MEMBER_ASSIGN(z, n, _)                                     \
+#define FUSION_VECTOR_MEMBER_DEREF_ASSIGN(z, n, _)                              \
     this->BOOST_PP_CAT(m, n) = *BOOST_PP_CAT(i, n);
 
-#define FUSION_AT_IMPL(z, n, _)                                                 \
+#define FUSION_VECTOR_MEMBER_MOVE(z, n, _)                                      \
+    this->BOOST_PP_CAT(m, n) = std::forward<                                    \
+        BOOST_PP_CAT(T, n)>(vec.BOOST_PP_CAT(m, n));
+
+#define FUSION_VECTOR_MEMBER_AT_IMPL(z, n, _)                                   \
     typename add_reference<T##n>::type                                          \
         at_impl(mpl::int_<n>) { return this->m##n; }                            \
     typename add_reference<typename add_const<T##n>::type>::type                \
         at_impl(mpl::int_<n>) const { return this->m##n; }
 
-#define FUSION_ITER_DECL_VAR(z, n, _)                                           \
+#define FUSION_VECTOR_MEMBER_ITER_DECL_VAR(z, n, _)                             \
     typedef typename result_of::next<                                           \
         BOOST_PP_CAT(I, BOOST_PP_DEC(n))>::type BOOST_PP_CAT(I, n);             \
     BOOST_PP_CAT(I, n) BOOST_PP_CAT(i, n)                                       \
@@ -36,25 +56,39 @@
 
 #define N BOOST_PP_ITERATION()
 
-    template <typename Derived, BOOST_PP_ENUM_PARAMS(N, typename T)>
-    struct BOOST_PP_CAT(vector_data, N) : sequence_base<Derived>
+    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+    struct BOOST_PP_CAT(vector_data, N)
     {
         BOOST_PP_CAT(vector_data, N)()
-            : BOOST_PP_ENUM(N, FUSION_MEMBER_DEFAULT_INIT, _) {}
+            : BOOST_PP_ENUM(N, FUSION_VECTOR_CTOR_DEFAULT_INIT, _) {}
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+        template <BOOST_PP_ENUM_PARAMS(N, typename U)>
+        BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_BINARY_PARAMS(N, U, && _)
+          , typename boost::enable_if<is_convertible<U0, T0> >::type* /*dummy*/ = 0
+        )
+            : BOOST_PP_ENUM(N, FUSION_VECTOR_CTOR_ARG_FWD, _) {}
+#endif
 
         BOOST_PP_CAT(vector_data, N)(
             BOOST_PP_ENUM_BINARY_PARAMS(
                 N, typename detail::call_param<T, >::type _))
-            : BOOST_PP_ENUM(N, FUSION_MEMBER_INIT, _) {}
+            : BOOST_PP_ENUM(N, FUSION_VECTOR_CTOR_INIT, _) {}
 
         BOOST_PP_CAT(vector_data, N)(
             BOOST_PP_CAT(vector_data, N) const& other)
-            : BOOST_PP_ENUM(N, FUSION_COPY_INIT, _) {}
+            : BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_CTOR_INIT, _) {}
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+        BOOST_PP_CAT(vector_data, N)(
+            BOOST_PP_CAT(vector_data, N)&& other)
+            : BOOST_PP_ENUM(N, FUSION_VECTOR_CTOR_FORWARD, _) {}
+#endif
 
         BOOST_PP_CAT(vector_data, N)&
         operator=(BOOST_PP_CAT(vector_data, N) const& vec)
         {
-            BOOST_PP_REPEAT(N, FUSION_MEMBER_ASSIGN, _)
+            BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_ASSIGN, _)
             return *this;
         }
 
@@ -64,21 +98,30 @@
         {
             typedef typename result_of::begin<Sequence const>::type I0;
             I0 i0 = fusion::begin(seq);
-            BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_ITER_DECL_VAR, _)
+            BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_VECTOR_MEMBER_ITER_DECL_VAR, _)
+            return BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_PARAMS(N, *i));
+        }
+
+        template <typename Sequence>
+        static BOOST_PP_CAT(vector_data, N)
+        init_from_sequence(Sequence& seq)
+        {
+            typedef typename result_of::begin<Sequence>::type I0;
+            I0 i0 = fusion::begin(seq);
+            BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_VECTOR_MEMBER_ITER_DECL_VAR, _)
             return BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_PARAMS(N, *i));
         }
 
-        BOOST_PP_REPEAT(N, FUSION_MEMBER_DECL, _)
+        BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_DECL, _)
     };
 
     template <BOOST_PP_ENUM_PARAMS(N, typename T)>
     struct BOOST_PP_CAT(vector, N)
-        : BOOST_PP_CAT(vector_data, N)<
-            BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)>
-          , BOOST_PP_ENUM_PARAMS(N, T)>
+      : BOOST_PP_CAT(vector_data, N)<BOOST_PP_ENUM_PARAMS(N, T)>
+      , sequence_base<BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> >
     {
         typedef BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> this_type;
-        typedef BOOST_PP_CAT(vector_data, N)<this_type, BOOST_PP_ENUM_PARAMS(N, T)> base_type;
+        typedef BOOST_PP_CAT(vector_data, N)<BOOST_PP_ENUM_PARAMS(N, T)> base_type;
         typedef mpl::BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> types;
         typedef vector_tag fusion_tag;
         typedef fusion_sequence_tag tag; // this gets picked up by MPL
@@ -96,6 +139,27 @@
                 N, typename detail::call_param<T, >::type _))
             : base_type(BOOST_PP_ENUM_PARAMS(N, _)) {}
 
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    template <BOOST_PP_ENUM_PARAMS(N, typename U)>
+#if (N == 1)
+        explicit
+        BOOST_PP_CAT(vector, N)(U0&& _0
+          , typename boost::enable_if<is_convertible<U0, T0> >::type* /*dummy*/ = 0
+          )
+         : base_type(std::forward<U0>(_0)) {}
+#else
+        BOOST_PP_CAT(vector, N)(BOOST_PP_ENUM_BINARY_PARAMS(N, U, && _))
+            : base_type(BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_FORWARD, _)) {}
+#endif
+
+        BOOST_PP_CAT(vector, N)(BOOST_PP_CAT(vector, N)&& rhs)
+            : base_type(std::forward<base_type>(rhs)) {}
+
+        BOOST_PP_CAT(vector, N)(BOOST_PP_CAT(vector, N) const& rhs)
+            : base_type(rhs) {}
+
+#endif
+
         template <BOOST_PP_ENUM_PARAMS(N, typename U)>
         BOOST_PP_CAT(vector, N)(
             BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, U)> const& vec)
@@ -105,7 +169,16 @@
         BOOST_PP_CAT(vector, N)(
             Sequence const& seq
 #if (N == 1)
-          , typename disable_if<is_convertible<Sequence, T0> >::type* /*dummy*/ = 0
+          , typename boost::disable_if<is_convertible<Sequence, T0> >::type* /*dummy*/ = 0
+#endif
+            )
+            : base_type(base_type::init_from_sequence(seq)) {}
+
+        template <typename Sequence>
+        BOOST_PP_CAT(vector, N)(
+            Sequence& seq
+#if (N == 1)
+          , typename boost::disable_if<is_convertible<Sequence, T0> >::type* /*dummy*/ = 0
 #endif
             )
             : base_type(base_type::init_from_sequence(seq)) {}
@@ -114,22 +187,38 @@
         BOOST_PP_CAT(vector, N)&
         operator=(BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, U)> const& vec)
         {
-            BOOST_PP_REPEAT(N, FUSION_MEMBER_ASSIGN, _)
+            BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_ASSIGN, _)
             return *this;
         }
 
         template <typename Sequence>
-        typename disable_if<is_convertible<Sequence, T0>, this_type&>::type
+        typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
         operator=(Sequence const& seq)
         {
             typedef typename result_of::begin<Sequence const>::type I0;
             I0 i0 = fusion::begin(seq);
-            BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_ITER_DECL_VAR, _)
-            BOOST_PP_REPEAT(N, FUSION_DEREF_MEMBER_ASSIGN, _)
+            BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_VECTOR_MEMBER_ITER_DECL_VAR, _)
+            BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_DEREF_ASSIGN, _)
             return *this;
         }
 
-        BOOST_PP_REPEAT(N, FUSION_AT_IMPL, _)
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+        BOOST_PP_CAT(vector, N)&
+        operator=(BOOST_PP_CAT(vector, N) const& vec)
+        {
+            base_type::operator=(vec);
+            return *this;
+        }
+
+        BOOST_PP_CAT(vector, N)&
+        operator=(BOOST_PP_CAT(vector, N)&& vec)
+        {
+            BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_MOVE, _)
+            return *this;
+        }
+#endif
+
+        BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_AT_IMPL, _)
 
         template<typename I>
         typename add_reference<typename mpl::at<types, I>::type>::type
@@ -148,3 +237,4 @@
 
 #undef N
 
+