mpl::sequence_tag specialization for adapted types

[SVN r58396]

include/boost/fusion/adapted/array/tag_of.hpp

@@ -21,6 +21,7 @@ namespace boost
 namespace boost { namespace fusion 
 {
     struct array_tag;
+    struct fusion_sequence_tag;
 
     namespace traits
     {
@@ -36,4 +37,22 @@ namespace boost { namespace fusion
     }
 }}
 
+namespace boost { namespace mpl
+{
+    template<typename>
+    struct sequence_tag;
+
+    template<typename T, std::size_t N>
+    struct sequence_tag<array<T,N> >
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+
+    template<typename T, std::size_t N>
+    struct sequence_tag<array<T,N> const>
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+}}
+
 #endif

include/boost/fusion/adapted/boost_tuple/tag_of.hpp

@@ -26,6 +26,7 @@ namespace boost { namespace tuples
 namespace boost { namespace fusion 
 {
     struct boost_tuple_tag;
+    struct fusion_sequence_tag;
 
     namespace traits
     {
@@ -60,4 +61,54 @@ namespace boost { namespace fusion
     }
 }}
 
+namespace boost { namespace mpl
+{
+    template<typename>
+    struct sequence_tag;
+
+    template <
+        class T0, class T1, class T2, class T3, class T4,
+        class T5, class T6, class T7, class T8, class T9
+    >
+    struct sequence_tag<tuples::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+
+    template <
+        class T0, class T1, class T2, class T3, class T4,
+        class T5, class T6, class T7, class T8, class T9
+    >
+    struct sequence_tag<
+        tuples::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> const
+    >
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+
+    template <class Head, class Tail>
+    struct sequence_tag<tuples::cons<Head, Tail> >
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+
+    template <class Head, class Tail>
+    struct sequence_tag<tuples::cons<Head, Tail> const>
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+
+    template <>
+    struct sequence_tag<tuples::null_type>
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+
+    template <>
+    struct sequence_tag<tuples::null_type const>
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+}}
+
 #endif

include/boost/fusion/adapted/class/adapt_assoc_class.hpp

@@ -62,6 +62,25 @@ namespace boost { namespace fusion { namespace extension {
             typedef class_tag type;                                             \
         };                                                                      \
     }}}                                                                         \
+                                                                                \
+    namespace boost { namespace mpl                                             \
+    {                                                                           \
+        template<typename>                                                      \
+        struct sequence_tag;                                                    \
+                                                                                \
+        template<>                                                              \
+        struct sequence_tag<name>                                               \
+        {                                                                       \
+            typedef fusion::fusion_sequence_tag type;                           \
+        };                                                                      \
+                                                                                \
+        template<>                                                              \
+        struct sequence_tag<name const>                                         \
+        {                                                                       \
+            typedef fusion::fusion_sequence_tag type;                           \
+        };                                                                      \
+    }}                                                                          \
+                                                                                \
     namespace boost { namespace fusion { namespace extension                    \
     {                                                                           \
         template <>                                                             \

include/boost/fusion/adapted/class/adapt_class.hpp

@@ -52,6 +52,25 @@
             typedef class_tag type;                                             \
         };                                                                      \
     }}}                                                                         \
+                                                                                \
+    namespace boost { namespace mpl                                             \
+    {                                                                           \
+        template<typename>                                                      \
+        struct sequence_tag;                                                    \
+                                                                                \
+        template<>                                                              \
+        struct sequence_tag<name>                                               \
+        {                                                                       \
+            typedef fusion::fusion_sequence_tag type;                           \
+        };                                                                      \
+                                                                                \
+        template<>                                                              \
+        struct sequence_tag<name const>                                         \
+        {                                                                       \
+            typedef fusion::fusion_sequence_tag type;                           \
+        };                                                                      \
+    }}                                                                          \
+                                                                                \
     namespace boost { namespace fusion { namespace extension                    \
     {                                                                           \
         template <>                                                             \

include/boost/fusion/adapted/class/extension.hpp

@@ -10,46 +10,51 @@
 
 #include <boost/type_traits/add_const.hpp>
 
-namespace boost { namespace fusion { namespace extension
+namespace boost { namespace fusion
 {
-    template <typename Class, int N>
+    struct fusion_sequence_tag;
-    struct class_member;
 
-    template <typename Class>
+    namespace extension
-    struct class_size;
-
-    template <typename Class, int N>
-    struct class_member<Class const, N> : class_member<Class, N> {};
-
-    template <typename Class>
-    struct class_size<Class const>
-        : class_size<Class>
-    {};
-
-    struct no_such_member;
-
-    template<typename Class, typename Key>
-    struct class_assoc_member
     {
-        typedef no_such_member type;
+        template <typename Class, int N>
-    };
+        struct class_member;
 
-    template<typename Class, typename Key>
+        template <typename Class>
-    struct class_assoc_member<Class const, Key>
+        struct class_size;
-    {
-        typedef typename
-            add_const<typename class_assoc_member<Class, Key>::type>::type
-        type;
 
-        static type&
+        template <typename Class, int N>
-        call(Class const& class_)
+        struct class_member<Class const, N> : class_member<Class, N> {};
+
+        template <typename Class>
+        struct class_size<Class const>
+            : class_size<Class>
+        {};
+
+        struct no_such_member;
+
+        template<typename Class, typename Key>
+        struct class_assoc_member
         {
-            return class_assoc_member<Class, Key>::call(
+            typedef no_such_member type;
-                const_cast<Class&>(class_));
+        };
-        }
-    };
 
-}}}
+        template<typename Class, typename Key>
+        struct class_assoc_member<Class const, Key>
+        {
+            typedef typename
+                add_const<typename class_assoc_member<Class, Key>::type>::type
+            type;
+
+            static type&
+            call(Class const& class_)
+            {
+                return class_assoc_member<Class, Key>::call(
+                    const_cast<Class&>(class_));
+            }
+        };
+
+    }
+}}
 
 #endif
 

include/boost/fusion/adapted/std_pair.hpp

@@ -16,6 +16,7 @@
 namespace boost { namespace fusion
 {
     struct struct_tag;
+    struct fusion_sequence_tag;
 
     namespace traits
     {
@@ -29,42 +30,60 @@ namespace boost { namespace fusion
             typedef struct_tag type;
         };
     }
-
-    namespace extension
-    {
-        template <typename Struct, int N>
-        struct struct_member;
-
-        template <typename Struct>
-        struct struct_size;
-
-        template <typename T1, typename T2>
-        struct struct_member<std::pair<T1, T2>, 0>
-        {
-            typedef T1 type;
-
-            static type& call(std::pair<T1, T2>& pair)
-            {
-                return pair.first;
-            }
-        };
-
-        template <typename T1, typename T2>
-        struct struct_member<std::pair<T1, T2>, 1>
-        {
-            typedef T2 type;
-
-            static type& call(std::pair<T1, T2>& pair)
-            {
-                return pair.second;
-            }
-        };
-
-        template <typename T1, typename T2>
-        struct struct_size<std::pair<T1, T2> > : mpl::int_<2>
-        {
-        };
-    }
 }}
 
+namespace boost { namespace mpl
+{
+    template<typename>
+    struct sequence_tag;
+
+    template<typename T1, typename T2>
+    struct sequence_tag<std::pair<T1, T2> >
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+
+    template<typename T1, typename T2>
+    struct sequence_tag<std::pair<T1, T2> const>
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+}}
+
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename Struct, int N>
+    struct struct_member;
+
+    template <typename Struct>
+    struct struct_size;
+
+    template <typename T1, typename T2>
+    struct struct_member<std::pair<T1, T2>, 0>
+    {
+        typedef T1 type;
+
+        static type& call(std::pair<T1, T2>& pair)
+        {
+            return pair.first;
+        }
+    };
+
+    template <typename T1, typename T2>
+    struct struct_member<std::pair<T1, T2>, 1>
+    {
+        typedef T2 type;
+
+        static type& call(std::pair<T1, T2>& pair)
+        {
+            return pair.second;
+        }
+    };
+
+    template <typename T1, typename T2>
+    struct struct_size<std::pair<T1, T2> > : mpl::int_<2>
+    {
+    };
+}}}
+
 #endif

include/boost/fusion/adapted/std_pair/tag_of.hpp

@@ -15,6 +15,7 @@
 namespace boost { namespace fusion {
 
     struct std_pair_tag;
+    struct fusion_sequence_tag;
 
     namespace traits
     {
@@ -26,4 +27,22 @@ namespace boost { namespace fusion {
     }
 }}
 
+namespace boost { namespace mpl
+{
+    template<typename>
+    struct sequence_tag;
+
+    template<typename T1, typename T2>
+    struct sequence_tag<std::pair<T1, T2> >
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+
+    template<typename T1, typename T2>
+    struct sequence_tag<std::pair<T1, T2> const>
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+}}
+
 #endif

include/boost/fusion/adapted/struct/adapt_assoc_struct.hpp

@@ -62,6 +62,25 @@ namespace boost { namespace fusion { namespace extension {
             typedef struct_tag type;                                            \
         };                                                                      \
     }}}                                                                         \
+                                                                                \
+    namespace boost { namespace mpl                                             \
+    {                                                                           \
+        template<typename>                                                      \
+        struct sequence_tag;                                                    \
+                                                                                \
+        template<>                                                              \
+        struct sequence_tag<name>                                               \
+        {                                                                       \
+            typedef fusion::fusion_sequence_tag type;                           \
+        };                                                                      \
+                                                                                \
+        template<>                                                              \
+        struct sequence_tag<name const>                                         \
+        {                                                                       \
+            typedef fusion::fusion_sequence_tag type;                           \
+        };                                                                      \
+    }}                                                                          \
+                                                                                \
     namespace boost { namespace fusion { namespace extension                    \
     {                                                                           \
         template <>                                                             \

include/boost/fusion/adapted/struct/adapt_struct.hpp

@@ -52,6 +52,25 @@
             typedef struct_tag type;                                            \
         };                                                                      \
     }}}                                                                         \
+                                                                                \
+    namespace boost { namespace mpl                                             \
+    {                                                                           \
+        template<typename>                                                      \
+        struct sequence_tag;                                                    \
+                                                                                \
+        template<>                                                              \
+        struct sequence_tag<name>                                               \
+        {                                                                       \
+            typedef fusion::fusion_sequence_tag type;                           \
+        };                                                                      \
+                                                                                \
+        template<>                                                              \
+        struct sequence_tag<name const>                                         \
+        {                                                                       \
+            typedef fusion::fusion_sequence_tag type;                           \
+        };                                                                      \
+    }}                                                                          \
+                                                                                \
     namespace boost { namespace fusion { namespace extension                    \
     {                                                                           \
         template <>                                                             \

include/boost/fusion/adapted/struct/extension.hpp

@@ -10,58 +10,63 @@
 
 #include <boost/type_traits/add_const.hpp>
 
-namespace boost { namespace fusion { namespace extension
+namespace boost { namespace fusion
 {
-    template <typename Struct, int N>
+    struct fusion_sequence_tag;
-    struct struct_member;
 
-    template <typename Struct>
+    namespace extension
-    struct struct_size;
-
-    template <typename Struct, int N>
-    struct struct_member<Struct const, N>
     {
-        typedef typename
+        template <typename Struct, int N>
-            add_const<typename struct_member<Struct, N>::type>::type
+        struct struct_member;
-        type;
 
-        static type&
+        template <typename Struct>
-        call(Struct const& struct_)
+        struct struct_size;
+
+        template <typename Struct, int N>
+        struct struct_member<Struct const, N>
         {
-            return struct_member<Struct, N>::call(
+            typedef typename
-                const_cast<Struct&>(struct_));
+                add_const<typename struct_member<Struct, N>::type>::type
-        }
+            type;
-    };
 
-    template <typename Struct>
+            static type&
-    struct struct_size<Struct const>
+            call(Struct const& struct_)
-        : struct_size<Struct>
+            {
-    {};
+                return struct_member<Struct, N>::call(
+                    const_cast<Struct&>(struct_));
+            }
+        };
 
-    struct no_such_member;
+        template <typename Struct>
+        struct struct_size<Struct const>
+            : struct_size<Struct>
+        {};
 
-    template<typename Struct, typename Key>
+        struct no_such_member;
-    struct struct_assoc_member
-    {
-        typedef no_such_member type;
-    };
 
-    template<typename Struct, typename Key>
+        template<typename Struct, typename Key>
-    struct struct_assoc_member<Struct const, Key>
+        struct struct_assoc_member
-    {
-        typedef typename
-            add_const<typename struct_assoc_member<Struct, Key>::type>::type
-        type;
-
-        static type&
-        call(Struct const& struct_)
         {
-            return struct_assoc_member<Struct, Key>::call(
+            typedef no_such_member type;
-                const_cast<Struct&>(struct_));
+        };
-        }
-    };
 
-}}}
+        template<typename Struct, typename Key>
+        struct struct_assoc_member<Struct const, Key>
+        {
+            typedef typename
+                add_const<typename struct_assoc_member<Struct, Key>::type>::type
+            type;
+
+            static type&
+            call(Struct const& struct_)
+            {
+                return struct_assoc_member<Struct, Key>::call(
+                    const_cast<Struct&>(struct_));
+            }
+        };
+
+    }
+}}
 
 #endif
 

test/sequence/adapt_assoc_struct.cpp

@@ -14,6 +14,7 @@
 #include <boost/fusion/sequence/intrinsic/back.hpp>
 #include <boost/fusion/sequence/intrinsic/has_key.hpp>
 #include <boost/fusion/sequence/intrinsic/at_key.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
 #include <boost/fusion/sequence/intrinsic/value_at_key.hpp>
 #include <boost/fusion/sequence/io/out.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
@@ -26,7 +27,10 @@
 #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/mpl.hpp>
 #include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
 #include <boost/mpl/assert.hpp>
 #include <boost/mpl/not.hpp>
 #include <boost/type_traits/is_same.hpp>
@@ -126,6 +130,13 @@ main()
         BOOST_TEST(at_key<ns::y_member>(p) == 3);
     }
 
+    {
+        BOOST_MPL_ASSERT((mpl::is_sequence<ns::point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            fusion::result_of::value_at_c<ns::point,0>::type
+          , mpl::front<ns::point>::type>));
+    }
+
     return boost::report_errors();
 }
 

test/sequence/adapt_class.cpp

@@ -11,6 +11,7 @@
 #include <boost/fusion/sequence/intrinsic/empty.hpp>
 #include <boost/fusion/sequence/intrinsic/front.hpp>
 #include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
 #include <boost/fusion/sequence/io/out.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/container/list/list.hpp>
@@ -22,7 +23,10 @@
 #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/mpl.hpp>
 #include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 #include <string>
@@ -113,6 +117,13 @@ main()
         l = p;
     }
 
+    {
+        BOOST_MPL_ASSERT((mpl::is_sequence<ns::point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            fusion::result_of::value_at_c<ns::point,0>::type
+          , mpl::front<ns::point>::type>));
+    }
+
     return boost::report_errors();
 }
 

test/sequence/adapt_struct.cpp

@@ -11,6 +11,7 @@
 #include <boost/fusion/sequence/intrinsic/empty.hpp>
 #include <boost/fusion/sequence/intrinsic/front.hpp>
 #include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
 #include <boost/fusion/sequence/io/out.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/container/list/list.hpp>
@@ -22,7 +23,10 @@
 #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/mpl.hpp>
 #include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 #include <string>
@@ -114,6 +118,14 @@ main()
         BOOST_MPL_ASSERT((is_same<result_of::next<b>::type, e>));
     }
 
+
+    {
+        BOOST_MPL_ASSERT((mpl::is_sequence<ns::point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            fusion::result_of::value_at_c<ns::point,0>::type
+          , mpl::front<ns::point>::type>));
+    }
+
     return boost::report_errors();
 }
 

test/sequence/array.cpp

@@ -15,8 +15,12 @@
 #include <boost/fusion/support/is_sequence.hpp>
 #include <boost/fusion/support/is_view.hpp>
 #include <boost/fusion/iterator.hpp>
+#include <boost/fusion/mpl.hpp>
 
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/front.hpp>
 #include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
 
 int main()
 {
@@ -37,5 +41,8 @@ int main()
     BOOST_TEST(size(arr) == 3);
     BOOST_TEST(distance(begin(arr), end(arr)) == 3);
 
+    BOOST_MPL_ASSERT((boost::mpl::is_sequence<array_type>));
+    BOOST_MPL_ASSERT((boost::is_same<int, boost::mpl::front<array_type>::type>));
+
     return boost::report_errors();
 }

test/sequence/boost_tuple.cpp

@@ -23,8 +23,11 @@
 #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/mpl.hpp>
 #include <boost/fusion/support/is_view.hpp>
 #include <boost/tuple/tuple.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/front.hpp>
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 #include <string>
@@ -96,6 +99,12 @@ main()
         BOOST_TEST(2u == fusion::distance(fusion::begin(t), fusion::end(t))); 
     } 
 
+    {
+        typedef boost::tuple<int, std::string> tuple_type;
+        BOOST_MPL_ASSERT((mpl::is_sequence<tuple_type>));
+        BOOST_MPL_ASSERT((boost::is_same<int, mpl::front<tuple_type>::type>));
+    }
+
     return boost::report_errors();
 }
 

test/sequence/std_pair.cpp

@@ -22,7 +22,10 @@
 #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/mpl.hpp>
 #include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/front.hpp>
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 #include <string>
@@ -86,6 +89,12 @@ main()
         l = std::make_pair(123, "Hola!!!");
     }
 
+    {
+        typedef std::pair<int, std::string> pair_type;
+        BOOST_MPL_ASSERT((mpl::is_sequence<pair_type>));
+        BOOST_MPL_ASSERT((boost::is_same<int, mpl::front<pair_type>::type>));
+    }
+
     return boost::report_errors();
 }