Fixed issue with vectorN calling the wrong vector_dataN constructor

include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp

@@ -86,7 +86,7 @@ namespace boost { namespace fusion
         vector1(vector1&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector1(vector1 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector1&
         operator=(vector1 const& vec)
         {
@@ -218,7 +218,7 @@ namespace boost { namespace fusion
         vector2(vector2&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector2(vector2 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector2&
         operator=(vector2 const& vec)
         {
@@ -348,7 +348,7 @@ namespace boost { namespace fusion
         vector3(vector3&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector3(vector3 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector3&
         operator=(vector3 const& vec)
         {
@@ -478,7 +478,7 @@ namespace boost { namespace fusion
         vector4(vector4&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector4(vector4 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector4&
         operator=(vector4 const& vec)
         {
@@ -608,7 +608,7 @@ namespace boost { namespace fusion
         vector5(vector5&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector5(vector5 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector5&
         operator=(vector5 const& vec)
         {
@@ -738,7 +738,7 @@ namespace boost { namespace fusion
         vector6(vector6&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector6(vector6 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector6&
         operator=(vector6 const& vec)
         {
@@ -868,7 +868,7 @@ namespace boost { namespace fusion
         vector7(vector7&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector7(vector7 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector7&
         operator=(vector7 const& vec)
         {
@@ -998,7 +998,7 @@ namespace boost { namespace fusion
         vector8(vector8&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector8(vector8 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector8&
         operator=(vector8 const& vec)
         {
@@ -1128,7 +1128,7 @@ namespace boost { namespace fusion
         vector9(vector9&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector9(vector9 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector9&
         operator=(vector9 const& vec)
         {
@@ -1258,7 +1258,7 @@ namespace boost { namespace fusion
         vector10(vector10&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector10(vector10 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector10&
         operator=(vector10 const& vec)
         {

include/boost/fusion/container/vector/detail/preprocessed/vector20.hpp

@@ -82,7 +82,7 @@ namespace boost { namespace fusion
         vector11(vector11&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector11(vector11 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector11&
         operator=(vector11 const& vec)
         {
@@ -212,7 +212,7 @@ namespace boost { namespace fusion
         vector12(vector12&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector12(vector12 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector12&
         operator=(vector12 const& vec)
         {
@@ -342,7 +342,7 @@ namespace boost { namespace fusion
         vector13(vector13&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector13(vector13 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector13&
         operator=(vector13 const& vec)
         {
@@ -472,7 +472,7 @@ namespace boost { namespace fusion
         vector14(vector14&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector14(vector14 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector14&
         operator=(vector14 const& vec)
         {
@@ -602,7 +602,7 @@ namespace boost { namespace fusion
         vector15(vector15&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector15(vector15 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector15&
         operator=(vector15 const& vec)
         {
@@ -732,7 +732,7 @@ namespace boost { namespace fusion
         vector16(vector16&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector16(vector16 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector16&
         operator=(vector16 const& vec)
         {
@@ -862,7 +862,7 @@ namespace boost { namespace fusion
         vector17(vector17&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector17(vector17 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector17&
         operator=(vector17 const& vec)
         {
@@ -992,7 +992,7 @@ namespace boost { namespace fusion
         vector18(vector18&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector18(vector18 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector18&
         operator=(vector18 const& vec)
         {
@@ -1122,7 +1122,7 @@ namespace boost { namespace fusion
         vector19(vector19&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector19(vector19 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector19&
         operator=(vector19 const& vec)
         {
@@ -1252,7 +1252,7 @@ namespace boost { namespace fusion
         vector20(vector20&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector20(vector20 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector20&
         operator=(vector20 const& vec)
         {

include/boost/fusion/container/vector/detail/preprocessed/vector30.hpp

@@ -82,7 +82,7 @@ namespace boost { namespace fusion
         vector21(vector21&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector21(vector21 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector21&
         operator=(vector21 const& vec)
         {
@@ -212,7 +212,7 @@ namespace boost { namespace fusion
         vector22(vector22&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector22(vector22 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector22&
         operator=(vector22 const& vec)
         {
@@ -342,7 +342,7 @@ namespace boost { namespace fusion
         vector23(vector23&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector23(vector23 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector23&
         operator=(vector23 const& vec)
         {
@@ -472,7 +472,7 @@ namespace boost { namespace fusion
         vector24(vector24&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector24(vector24 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector24&
         operator=(vector24 const& vec)
         {
@@ -602,7 +602,7 @@ namespace boost { namespace fusion
         vector25(vector25&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector25(vector25 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector25&
         operator=(vector25 const& vec)
         {
@@ -732,7 +732,7 @@ namespace boost { namespace fusion
         vector26(vector26&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector26(vector26 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector26&
         operator=(vector26 const& vec)
         {
@@ -862,7 +862,7 @@ namespace boost { namespace fusion
         vector27(vector27&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector27(vector27 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector27&
         operator=(vector27 const& vec)
         {
@@ -992,7 +992,7 @@ namespace boost { namespace fusion
         vector28(vector28&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector28(vector28 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector28&
         operator=(vector28 const& vec)
         {
@@ -1122,7 +1122,7 @@ namespace boost { namespace fusion
         vector29(vector29&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector29(vector29 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector29&
         operator=(vector29 const& vec)
         {
@@ -1252,7 +1252,7 @@ namespace boost { namespace fusion
         vector30(vector30&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector30(vector30 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector30&
         operator=(vector30 const& vec)
         {

include/boost/fusion/container/vector/detail/preprocessed/vector40.hpp

@@ -82,7 +82,7 @@ namespace boost { namespace fusion
         vector31(vector31&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector31(vector31 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector31&
         operator=(vector31 const& vec)
         {
@@ -212,7 +212,7 @@ namespace boost { namespace fusion
         vector32(vector32&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector32(vector32 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector32&
         operator=(vector32 const& vec)
         {
@@ -342,7 +342,7 @@ namespace boost { namespace fusion
         vector33(vector33&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector33(vector33 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector33&
         operator=(vector33 const& vec)
         {
@@ -472,7 +472,7 @@ namespace boost { namespace fusion
         vector34(vector34&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector34(vector34 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector34&
         operator=(vector34 const& vec)
         {
@@ -602,7 +602,7 @@ namespace boost { namespace fusion
         vector35(vector35&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector35(vector35 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector35&
         operator=(vector35 const& vec)
         {
@@ -732,7 +732,7 @@ namespace boost { namespace fusion
         vector36(vector36&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector36(vector36 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector36&
         operator=(vector36 const& vec)
         {
@@ -862,7 +862,7 @@ namespace boost { namespace fusion
         vector37(vector37&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector37(vector37 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector37&
         operator=(vector37 const& vec)
         {
@@ -992,7 +992,7 @@ namespace boost { namespace fusion
         vector38(vector38&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector38(vector38 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector38&
         operator=(vector38 const& vec)
         {
@@ -1122,7 +1122,7 @@ namespace boost { namespace fusion
         vector39(vector39&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector39(vector39 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector39&
         operator=(vector39 const& vec)
         {
@@ -1252,7 +1252,7 @@ namespace boost { namespace fusion
         vector40(vector40&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector40(vector40 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector40&
         operator=(vector40 const& vec)
         {

include/boost/fusion/container/vector/detail/preprocessed/vector50.hpp

@@ -82,7 +82,7 @@ namespace boost { namespace fusion
         vector41(vector41&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector41(vector41 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector41&
         operator=(vector41 const& vec)
         {
@@ -212,7 +212,7 @@ namespace boost { namespace fusion
         vector42(vector42&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector42(vector42 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector42&
         operator=(vector42 const& vec)
         {
@@ -342,7 +342,7 @@ namespace boost { namespace fusion
         vector43(vector43&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector43(vector43 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector43&
         operator=(vector43 const& vec)
         {
@@ -472,7 +472,7 @@ namespace boost { namespace fusion
         vector44(vector44&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector44(vector44 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector44&
         operator=(vector44 const& vec)
         {
@@ -602,7 +602,7 @@ namespace boost { namespace fusion
         vector45(vector45&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector45(vector45 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector45&
         operator=(vector45 const& vec)
         {
@@ -732,7 +732,7 @@ namespace boost { namespace fusion
         vector46(vector46&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector46(vector46 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector46&
         operator=(vector46 const& vec)
         {
@@ -862,7 +862,7 @@ namespace boost { namespace fusion
         vector47(vector47&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector47(vector47 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector47&
         operator=(vector47 const& vec)
         {
@@ -992,7 +992,7 @@ namespace boost { namespace fusion
         vector48(vector48&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector48(vector48 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector48&
         operator=(vector48 const& vec)
         {
@@ -1122,7 +1122,7 @@ namespace boost { namespace fusion
         vector49(vector49&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector49(vector49 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector49&
         operator=(vector49 const& vec)
         {
@@ -1252,7 +1252,7 @@ namespace boost { namespace fusion
         vector50(vector50&& rhs)
             : base_type(std::forward<base_type>(rhs)) {}
         vector50(vector50 const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
         vector50&
         operator=(vector50 const& vec)
         {

include/boost/fusion/container/vector/detail/vector_n.hpp

@@ -164,7 +164,7 @@ FUSION_HASH if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
             : base_type(std::forward<base_type>(rhs)) {}
 
         BOOST_PP_CAT(vector, N)(BOOST_PP_CAT(vector, N) const& rhs)
-            : base_type(rhs) {}
+            : base_type(static_cast<base_type const&>(rhs)) {}
 
         BOOST_PP_CAT(vector, N)&
         operator=(BOOST_PP_CAT(vector, N) const& vec)