Merge pull request #7 from Flast/pr/adapt/tuple

Additional supports adapting (BoostTuple implementations

include/boost/fusion/adapted/boost_tuple.hpp

@@ -17,5 +17,7 @@
 #include <boost/fusion/adapted/boost_tuple/detail/size_impl.hpp>
 #include <boost/fusion/adapted/boost_tuple/detail/at_impl.hpp>
 #include <boost/fusion/adapted/boost_tuple/detail/value_at_impl.hpp>
+#include <boost/fusion/adapted/boost_tuple/detail/convert_impl.hpp>
+#include <boost/fusion/adapted/boost_tuple/mpl/clear.hpp>
 
 #endif

include/boost/fusion/adapted/boost_tuple/detail/build_cons.hpp

@@ -0,0 +1,59 @@
+/*=============================================================================
+    Copyright (c) 2012-2014 Kohei Takahashi
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_BUILD_CONS_10172012_0130)
+#define BOOST_FUSION_BUILD_CONS_10172012_0130
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <
+        typename First
+      , typename Last
+      , bool is_empty = result_of::equal_to<First, Last>::value>
+    struct build_tuple_cons;
+
+    template <typename First, typename Last>
+    struct build_tuple_cons<First, Last, true>
+    {
+        typedef boost::tuples::null_type type;
+
+        BOOST_FUSION_GPU_ENABLED
+        static type
+        call(First const&, Last const&)
+        {
+            return type();
+        }
+    };
+
+    template <typename First, typename Last>
+    struct build_tuple_cons<First, Last, false>
+    {
+        typedef
+            build_tuple_cons<typename result_of::next<First>::type, Last>
+        next_build_tuple_cons;
+
+        typedef boost::tuples::cons<
+            typename result_of::value_of<First>::type
+          , typename next_build_tuple_cons::type>
+        type;
+
+        BOOST_FUSION_GPU_ENABLED
+        static type
+        call(First const& f, Last const& l)
+        {
+            typename result_of::value_of<First>::type v = *f;
+            return type(v, next_build_tuple_cons::call(fusion::next(f), l));
+        }
+    };
+}}}
+
+#endif

include/boost/fusion/adapted/boost_tuple/detail/convert_impl.hpp

@@ -0,0 +1,50 @@
+/*=============================================================================
+    Copyright (c) 2012-2014 Kohei Takahashi
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_CONVERT_IMPL_10172012_0120)
+#define BOOST_FUSION_CONVERT_IMPL_10172012_0120
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/fusion/adapted/boost_tuple/detail/build_cons.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+
+namespace boost { namespace fusion
+{
+    struct boost_tuple_tag;
+
+    namespace extension
+    {
+        template <typename T>
+        struct convert_impl;
+
+        template <>
+        struct convert_impl<boost_tuple_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename
+                    detail::build_tuple_cons<
+                        typename result_of::begin<Sequence>::type
+                      , typename result_of::end<Sequence>::type
+                    >
+                build_tuple_cons;
+
+                typedef typename build_tuple_cons::type type;
+
+                BOOST_FUSION_GPU_ENABLED
+                static type
+                call(Sequence& seq)
+                {
+                    return build_tuple_cons::call(fusion::begin(seq), fusion::end(seq));
+                }
+            };
+        };
+    }
+}}
+
+#endif

include/boost/fusion/adapted/boost_tuple/mpl/clear.hpp

@@ -0,0 +1,23 @@
+/*=============================================================================
+    Copyright (c) 2012 Kohei Takahashi
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_CLEAR_10172012_0100)
+#define BOOST_FUSION_CLEAR_10172012_0100
+
+#include <boost/mpl/identity.hpp>
+#include <boost/fusion/adapted/boost_tuple/tag_of.hpp>
+
+namespace boost { namespace fusion { namespace detail {
+
+  template <typename Tag>
+  struct clear;
+
+  template <>
+  struct clear<boost_tuple_tag> : mpl::identity<boost::tuple<> > {};
+
+}}}
+
+#endif

include/boost/fusion/adapted/std_tuple.hpp

@@ -16,7 +16,9 @@
 #include <boost/fusion/adapted/std_tuple/detail/size_impl.hpp>
 #include <boost/fusion/adapted/std_tuple/detail/at_impl.hpp>
 #include <boost/fusion/adapted/std_tuple/detail/value_at_impl.hpp>
+#include <boost/fusion/adapted/std_tuple/detail/convert_impl.hpp>
 #include <boost/fusion/adapted/std_tuple/std_tuple_iterator.hpp>
 #include <boost/fusion/adapted/std_tuple/tag_of.hpp>
+#include <boost/fusion/adapted/std_tuple/mpl/clear.hpp>
 
 #endif

include/boost/fusion/adapted/std_tuple/detail/build_std_tuple.hpp

@@ -0,0 +1,105 @@
+/*=============================================================================
+    Copyright (c) 2014 Kohei Takahashi
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_BUILD_STD_TUPLE_05292014_0100)
+#define BOOST_FUSION_BUILD_STD_TUPLE_05292014_0100
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <tuple>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename First, typename Last
+      , bool is_empty = result_of::equal_to<First, Last>::value
+    >
+    struct build_std_tuple;
+
+    template <typename First, typename Last>
+    struct build_std_tuple<First, Last, true>
+    {
+        typedef std::tuple<> type;
+        BOOST_FUSION_GPU_ENABLED
+        static type
+        call(First const&, Last const&)
+        {
+            return type();
+        }
+    };
+
+    template <int ...> struct indexed_tuple { };
+
+    template <int, typename = indexed_tuple<>>
+    struct make_indexed_tuple;
+
+    template <int Head, int ...Tail>
+    struct make_indexed_tuple<Head, indexed_tuple<Tail...>>
+    {
+        typedef typename
+            boost::mpl::eval_if_c<
+                (Head == 0),
+                boost::mpl::identity<indexed_tuple<Tail...>>,
+                make_indexed_tuple<Head - 1, indexed_tuple<Head - 1, Tail...>>
+            >::type
+        type;
+    };
+
+    template <typename T, typename Rest>
+    struct push_front_std_tuple;
+
+    template <typename T, typename ...Rest>
+    struct push_front_std_tuple<T, std::tuple<Rest...>>
+    {
+        typedef std::tuple<T, Rest...> type;
+
+        template <int ...I>
+        BOOST_FUSION_GPU_ENABLED
+        static type
+        indexed_call(T const& first, std::tuple<Rest...> const& rest, indexed_tuple<I...>)
+        {
+            return type(first, std::get<I>(rest)...);
+        }
+
+        BOOST_FUSION_GPU_ENABLED
+        static type
+        call(T const& first, std::tuple<Rest...> const& rest)
+        {
+            typedef typename make_indexed_tuple<sizeof...(Rest)>::type gen;
+            return indexed_call(first, rest, gen());
+        }
+    };
+
+    template <typename First, typename Last>
+    struct build_std_tuple<First, Last, false>
+    {
+        typedef
+            build_std_tuple<typename result_of::next<First>::type, Last>
+        next_build_std_tuple;
+
+        typedef push_front_std_tuple<
+            typename result_of::value_of<First>::type
+          , typename next_build_std_tuple::type>
+        push_front;
+
+        typedef typename push_front::type type;
+
+        BOOST_FUSION_GPU_ENABLED
+        static type
+        call(First const& f, Last const& l)
+        {
+            typename result_of::value_of<First>::type v = *f;
+            return push_front::call(
+                v, next_build_std_tuple::call(fusion::next(f), l));
+        }
+    };
+}}}
+
+#endif

include/boost/fusion/adapted/std_tuple/detail/convert_impl.hpp

@@ -0,0 +1,48 @@
+/*=============================================================================
+    Copyright (c) 2012-2014 Kohei Takahashi
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_CONVERT_IMPL_10172012_0940)
+#define BOOST_FUSION_CONVERT_IMPL_10172012_0940
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/adapted/std_tuple/detail/build_std_tuple.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+
+namespace boost { namespace fusion
+{
+    struct std_tuple_tag;
+
+    namespace extension
+    {
+        template <typename T>
+        struct convert_impl;
+
+        template <>
+        struct convert_impl<std_tuple_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef detail::build_std_tuple<
+                    typename result_of::begin<Sequence>::type
+                  , typename result_of::end<Sequence>::type
+                > gen;
+
+                typedef typename gen::type type;
+
+                BOOST_FUSION_GPU_ENABLED
+                static type
+                call(Sequence& seq)
+                {
+                    return gen::call(begin(seq), end(seq));
+                }
+            };
+        };
+    }
+}}
+
+#endif

include/boost/fusion/adapted/std_tuple/mpl/clear.hpp

@@ -0,0 +1,23 @@
+/*=============================================================================
+    Copyright (c) 2012 Kohei Takahashi
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_CLEAR_10172012_0940)
+#define BOOST_FUSION_CLEAR_10172012_0940
+
+#include <boost/mpl/identity.hpp>
+#include <boost/fusion/adapted/std_tuple/tag_of.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+  template <typename Tag>
+  struct clear;
+
+  template <>
+  struct clear<std_tuple_tag> : mpl::identity<std::tuple<> > {};
+
+}}}
+
+#endif

test/Jamfile

@@ -150,6 +150,7 @@ project
     [ run sequence/define_tpl_struct.cpp : : : : ]
     [ run sequence/define_tpl_struct_inline.cpp : : : : ]
     [ run sequence/define_assoc_tpl_struct.cpp : : : : ]
+    [ run sequence/std_tuple.cpp : : : : ]
     [ run sequence/std_tuple_iterator.cpp : : : : ]
     [ run sequence/ref_vector.cpp : : : : ]
     [ run sequence/flatten_view.cpp : : : : ]

test/sequence/boost_tuple.cpp

@@ -23,6 +23,7 @@
 #include <boost/fusion/sequence/comparison/less_equal.hpp>
 #include <boost/fusion/sequence/comparison/greater.hpp>
 #include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/sequence/convert.hpp>
 #include <boost/fusion/mpl.hpp>
 #include <boost/fusion/support/is_view.hpp>
 #include <boost/tuple/tuple.hpp>
@@ -87,7 +88,14 @@ main()
         fusion::list<int, std::string> l(tuples::make_tuple(123, "Hola!!!"));
         l = tuples::make_tuple(123, "Hola!!!");
     }
-    
+
+    {
+        // conversion vector to boost tuple
+        boost::tuple<int, std::string> t = convert<boost_tuple_tag>(make_vector(123, "Hola!!!"));
+        BOOST_TEST(get<0>(t) == 123);
+        BOOST_TEST(get<1>(t) == "Hola!!!");
+    }
+
     { 
         // test from Ticket #1601, submitted by Shunsuke Sogame 
         // expanded by Stjepan Rajko 

test/sequence/std_tuple.cpp

@@ -0,0 +1,47 @@
+/*=============================================================================
+    Copyright (c) 2014 Kohei Takahashi
+
+    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)
+==============================================================================*/
+
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/std_tuple.hpp>
+#include <boost/fusion/sequence/convert.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <tuple>
+#include <string>
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+// The convert only supports implementations using variadic templates
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    {
+        // conversion vector to std tuple
+        std::tuple<int, std::string> t = convert<std_tuple_tag>(make_vector(123, "Hola!!!"));
+        BOOST_TEST(std::get<0>(t) == 123);
+        BOOST_TEST(std::get<1>(t) == "Hola!!!");
+    }
+#endif
+
+    return boost::report_errors();
+}
+
+#else
+
+int
+main()
+{
+    return 0;
+}
+
+#endif