Create a branch for autoprefixing

[SVN r59996]

include/boost/fusion/adapted/class.hpp

@@ -1,29 +1,18 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2010 Christopher Schmidt
 
     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_CLASS_OCTOBER_4_2009_839PM)
-#define BOOST_FUSION_CLASS_OCTOBER_4_2009_839PM
 
-#include <boost/fusion/adapted/class/extension.hpp>
-#include <boost/fusion/adapted/class/adapt_class.hpp>
-#include <boost/fusion/adapted/class/adapt_class_named.hpp>
+#ifndef BOOST_FUSION_ADAPTED_CLASS_HPP
+#define BOOST_FUSION_ADAPTED_CLASS_HPP
+
+#include <boost/fusion/adapted/class/adapt_assoc_class_named.hpp>
 #include <boost/fusion/adapted/class/adapt_assoc_class.hpp>
-#include <boost/fusion/adapted/class/class_iterator.hpp>
-
-#include <boost/fusion/adapted/class/detail/at_impl.hpp>
-#include <boost/fusion/adapted/class/detail/at_key_impl.hpp>
-#include <boost/fusion/adapted/class/detail/begin_impl.hpp>
-#include <boost/fusion/adapted/class/detail/category_of_impl.hpp>
-#include <boost/fusion/adapted/class/detail/end_impl.hpp>
-#include <boost/fusion/adapted/class/detail/has_key_impl.hpp>
-#include <boost/fusion/adapted/class/detail/is_sequence_impl.hpp>
-#include <boost/fusion/adapted/class/detail/is_view_impl.hpp>
-#include <boost/fusion/adapted/class/detail/size_impl.hpp>
-#include <boost/fusion/adapted/class/detail/value_at_impl.hpp>
-#include <boost/fusion/adapted/class/detail/value_at_key_impl.hpp>
+#include <boost/fusion/adapted/class/adapt_class_named.hpp>
+#include <boost/fusion/adapted/class/adapt_class.hpp>
 
 #endif

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

@@ -1,113 +1,76 @@
 /*=============================================================================
     Copyright (c) 2001-2009 Joel de Guzman
     Copyright (c) 2007 Dan Marsden
+    Copyright (c) 2010 Christopher Schmidt
 
     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_ADAPT_ASSOC_CLASS_OCTOBER_4_2009_840PM)
-#define BOOST_FUSION_ADAPT_ASSOC_CLASS_OCTOBER_4_2009_840PM
 
-#include <boost/fusion/support/tag_of_fwd.hpp>
-#include <boost/fusion/adapted/class/extension.hpp>
-#include <boost/fusion/adapted/class/class_iterator.hpp>
-#include <boost/fusion/adapted/class/detail/is_view_impl.hpp>
-#include <boost/fusion/adapted/class/detail/is_sequence_impl.hpp>
-#include <boost/fusion/adapted/class/detail/category_of_impl.hpp>
-#include <boost/fusion/adapted/class/detail/begin_impl.hpp>
-#include <boost/fusion/adapted/class/detail/end_impl.hpp>
-#include <boost/fusion/adapted/class/detail/size_impl.hpp>
-#include <boost/fusion/adapted/class/detail/at_impl.hpp>
-#include <boost/fusion/adapted/class/detail/value_at_impl.hpp>
-#include <boost/fusion/adapted/class/detail/has_key_impl.hpp>
-#include <boost/fusion/adapted/class/detail/at_key_impl.hpp>
-#include <boost/fusion/adapted/class/detail/value_at_key_impl.hpp>
+#ifndef BOOST_FUSION_ADAPTED_CLASS_ADAPT_ASSOC_CLASS_HPP
+#define BOOST_FUSION_ADAPTED_CLASS_ADAPT_ASSOC_CLASS_HPP
 
 #include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/seq/for_each_i.hpp>
+#include <boost/preprocessor/empty.hpp>
 #include <boost/preprocessor/tuple/elem.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/config/no_tr1/utility.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
 
-namespace boost { namespace fusion { namespace extension {
-    template<typename Class, typename Key>
-    struct class_assoc_member;
-}}}
+#include <boost/fusion/adapted/struct/detail/extension.hpp>
+#include <boost/fusion/adapted/struct/detail/adapt_base.hpp>
+#include <boost/fusion/adapted/struct/detail/at_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/is_view_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/is_sequence_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/value_at_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/category_of_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/size_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/begin_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/end_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/value_of_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/deref_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/deref_data_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/key_of_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/value_of_data_impl.hpp>
+#include <boost/fusion/adapted/class/detail/extension.hpp>
+#include <boost/fusion/adapted/class/detail/adapt_base.hpp>
 
+#define BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_0(A, B, C, D, E)\
+    ((A, B, C, D, E)) BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_1
+#define BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_1(A, B, C, D, E)\
+    ((A, B, C, D, E)) BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_0
+#define BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_0_END
+#define BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_1_END
 
-#define BOOST_FUSION_ADAPT_ASSOC_CLASS(name, bseq)                             \
-    BOOST_FUSION_ADAPT_ASSOC_CLASS_I(                                           \
-        name, BOOST_PP_CAT(BOOST_FUSION_ADAPT_ASSOC_CLASS_X bseq, 0))           \
-    /***/
-
-#define BOOST_FUSION_ADAPT_ASSOC_CLASS_X(x, y, z) ((x, y, z)) BOOST_FUSION_ADAPT_ASSOC_CLASS_Y
-#define BOOST_FUSION_ADAPT_ASSOC_CLASS_Y(x, y, z) ((x, y, z)) BOOST_FUSION_ADAPT_ASSOC_CLASS_X
-#define BOOST_FUSION_ADAPT_ASSOC_CLASS_X0
-#define BOOST_FUSION_ADAPT_ASSOC_CLASS_Y0
-
-// BOOST_FUSION_ADAPT_ASSOC_CLASS_I generates the overarching structure and uses
-// SEQ_FOR_EACH_I to generate the "linear" substructures.
-// Thanks to Paul Mensonides for the PP macro help
-
-#define BOOST_FUSION_ADAPT_ASSOC_CLASS_I(name, seq)                             \
-    namespace boost { namespace fusion { namespace traits                       \
-    {                                                                           \
-        template <>                                                             \
-        struct tag_of<name>                                                     \
-        {                                                                       \
-            typedef class_tag type;                                             \
-        };                                                                      \
-    }}}                                                                         \
+#define BOOST_FUSION_ADAPT_ASSOC_CLASS_C(                                       \
+    TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE)                                \
                                                                                 \
-    namespace boost { namespace mpl                                             \
-    {                                                                           \
-        template<typename>                                                      \
-        struct sequence_tag;                                                    \
+    BOOST_FUSION_ADAPT_CLASS_C_BASE(TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,ATTRIBUTE,5) \
                                                                                 \
-        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<                                                                   \
+        BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
+    >                                                                           \
+    struct struct_assoc_key<BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ), I> \
     {                                                                           \
-        template <>                                                             \
-        struct class_size<name> : mpl::int_<BOOST_PP_SEQ_SIZE(seq)> {};         \
-        BOOST_PP_SEQ_FOR_EACH_I(BOOST_FUSION_ADAPT_ASSOC_CLASS_C, name, seq)    \
-    }}}                                                                         \
-    /***/
-
-#define BOOST_FUSION_ADAPT_ASSOC_CLASS_C(r, name, i, xy)                        \
-    template <>                                                                 \
-    struct class_member<name, i>                                                \
-    {                                                                           \
-        typedef BOOST_PP_TUPLE_ELEM(3, 0, xy) type;                             \
-        static type& call(name& class_)                                         \
-        {                                                                       \
-            return class_.BOOST_PP_TUPLE_ELEM(3, 1, xy);                        \
-        };                                                                      \
-    };                                                                          \
-    template<>                                                                  \
-    struct class_assoc_member<name, BOOST_PP_TUPLE_ELEM(3, 2, xy)>              \
-    {                                                                           \
-        typedef BOOST_PP_TUPLE_ELEM(3, 0, xy) type;                             \
-        static type& call(name& class_)                                         \
-        {                                                                       \
-            return class_.BOOST_PP_TUPLE_ELEM(3, 1, xy);                        \
-        };                                                                      \
+        typedef BOOST_PP_TUPLE_ELEM(5, 4, ATTRIBUTE) type;                      \
     };
-    /***/
+
+#define BOOST_FUSION_ADAPT_ASSOC_TPL_CLASS(                                     \
+    TEMPLATE_PARAMS_SEQ, NAME_SEQ, ATTRIBUTES)                                  \
+                                                                                \
+    BOOST_FUSION_ADAPT_STRUCT_BASE(                                             \
+        (1)TEMPLATE_PARAMS_SEQ,                                                 \
+        (1)NAME_SEQ,                                                            \
+        assoc_struct_tag,                                                       \
+        BOOST_PP_CAT(BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_0 ATTRIBUTES,_END),  \
+        BOOST_FUSION_ADAPT_ASSOC_CLASS_C)
+
+#define BOOST_FUSION_ADAPT_ASSOC_CLASS(NAME, ATTRIBUTES)                        \
+    BOOST_FUSION_ADAPT_STRUCT_BASE(                                             \
+        (0),                                                                    \
+        (0)(NAME),                                                              \
+        assoc_struct_tag,                                                       \
+        BOOST_PP_CAT(BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_0 ATTRIBUTES,_END),  \
+        BOOST_FUSION_ADAPT_ASSOC_CLASS_C)
 
 #endif

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

@@ -0,0 +1,28 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ADAPTED_CLASS_ADAPT_ASSOC_CLASS_NAMED_HPP
+#define BOOST_FUSION_ADAPTED_CLASS_ADAPT_ASSOC_CLASS_NAMED_HPP
+
+#include <boost/fusion/adapted/class/adapt_assoc_class.hpp>
+#include <boost/fusion/adapted/struct/detail/proxy_type.hpp>
+
+#define BOOST_FUSION_ADAPT_ASSOC_CLASS_NAMED_NS(                                \
+    WRAPPED_TYPE, NAMESPACE_SEQ, NAME, ATTRIBUTES)                              \
+                                                                                \
+    BOOST_FUSION_ADAPT_STRUCT_DEFINE_PROXY_TYPE(                                \
+        WRAPPED_TYPE,(0)NAMESPACE_SEQ,NAME)                                     \
+                                                                                \
+    BOOST_FUSION_ADAPT_ASSOC_CLASS(                                             \
+        BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION((0)NAMESPACE_SEQ)NAME,  \
+        ATTRIBUTES)
+
+#define BOOST_FUSION_ADAPT_ASSOC_CLASS_NAMED(WRAPPED_TYPE, NAME, ATTRIBUTES)    \
+    BOOST_FUSION_ADAPT_ASSOC_CLASS_NAMED_NS(                                    \
+        WRAPPED_TYPE,(boost)(fusion)(adapted),NAME,ATTRIBUTES)
+
+#endif

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

@@ -1,132 +1,63 @@
 /*=============================================================================
     Copyright (c) 2001-2009 Joel de Guzman
     Copyright (c) 2009-2010 Hartmut Kaiser
+    Copyright (c) 2010 Christopher Schmidt
 
     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_ADAPT_CLASS_OCTOBER_4_2009_840PM)
-#define BOOST_FUSION_ADAPT_CLASS_OCTOBER_4_2009_840PM
 
-#include <boost/fusion/support/tag_of_fwd.hpp>
-#include <boost/fusion/adapted/class/extension.hpp>
-#include <boost/fusion/adapted/class/class_iterator.hpp>
-#include <boost/fusion/adapted/class/detail/is_view_impl.hpp>
-#include <boost/fusion/adapted/class/detail/is_sequence_impl.hpp>
-#include <boost/fusion/adapted/class/detail/category_of_impl.hpp>
-#include <boost/fusion/adapted/class/detail/begin_impl.hpp>
-#include <boost/fusion/adapted/class/detail/end_impl.hpp>
-#include <boost/fusion/adapted/class/detail/size_impl.hpp>
-#include <boost/fusion/adapted/class/detail/at_impl.hpp>
-#include <boost/fusion/adapted/class/detail/value_at_impl.hpp>
+#ifndef BOOST_FUSION_ADAPTED_CLASS_ADAPT_CLASS_HPP
+#define BOOST_FUSION_ADAPTED_CLASS_ADAPT_CLASS_HPP
 
 #include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/seq/for_each_i.hpp>
-#include <boost/preprocessor/tuple/elem.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/config/no_tr1/utility.hpp>
+#include <boost/preprocessor/empty.hpp>
 #include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/remove_const.hpp>
 
-#define BOOST_FUSION_ADAPT_CLASS(name, bseq)                                    \
-    BOOST_FUSION_ADAPT_CLASS_I(                                                 \
-        name, BOOST_PP_CAT(BOOST_FUSION_ADAPT_CLASS_X bseq, 0))                 \
-    /***/
+#include <boost/fusion/adapted/struct/detail/extension.hpp>
+#include <boost/fusion/adapted/struct/detail/adapt_base.hpp>
+#include <boost/fusion/adapted/struct/detail/at_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/is_view_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/is_sequence_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/value_at_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/category_of_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/size_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/begin_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/end_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/value_of_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/deref_impl.hpp>
+#include <boost/fusion/adapted/class/detail/extension.hpp>
+#include <boost/fusion/adapted/class/detail/adapt_base.hpp>
 
-#define BOOST_FUSION_ADAPT_CLASS_X(w, x, y, z) ((w, x, y, z)) BOOST_FUSION_ADAPT_CLASS_Y
-#define BOOST_FUSION_ADAPT_CLASS_Y(w, x, y, z) ((w, x, y, z)) BOOST_FUSION_ADAPT_CLASS_X
-#define BOOST_FUSION_ADAPT_CLASS_X0
-#define BOOST_FUSION_ADAPT_CLASS_Y0
+#define BOOST_FUSION_ADAPT_CLASS_FILLER_0(A, B, C, D)\
+    ((A, B, C, D)) BOOST_FUSION_ADAPT_CLASS_FILLER_1
+#define BOOST_FUSION_ADAPT_CLASS_FILLER_1(A, B, C, D)\
+    ((A, B, C, D)) BOOST_FUSION_ADAPT_CLASS_FILLER_0
+#define BOOST_FUSION_ADAPT_CLASS_FILLER_0_END
+#define BOOST_FUSION_ADAPT_CLASS_FILLER_1_END
 
-// BOOST_FUSION_ADAPT_CLASS_I generates the overarching structure and uses
-// SEQ_FOR_EACH_I to generate the "linear" substructures.
-// Thanks to Paul Mensonides for the PP macro help
+#define BOOST_FUSION_ADAPT_CLASS_C(TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE) \
+    BOOST_FUSION_ADAPT_CLASS_C_BASE(                                            \
+        TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE, 4)
 
-#define BOOST_FUSION_ADAPT_CLASS_I(name, seq)                                   \
-    namespace boost { namespace fusion { namespace traits                       \
-    {                                                                           \
-        template <>                                                             \
-        struct tag_of<name>                                                     \
-        {                                                                       \
-            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 <>                                                             \
-        struct class_size<name> : mpl::int_<BOOST_PP_SEQ_SIZE(seq)> {};         \
-        template <typename T, int N> struct class_member_proxy;                 \
-        BOOST_PP_SEQ_FOR_EACH_I(BOOST_FUSION_ADAPT_CLASS_C, name, seq)          \
-    }}}                                                                         \
-    /***/
+#define BOOST_FUSION_ADAPT_TPL_CLASS(TEMPLATE_PARAMS_SEQ, NAME_SEQ , ATTRIBUTES)\
+    BOOST_FUSION_ADAPT_STRUCT_BASE(                                             \
+        (1)TEMPLATE_PARAMS_SEQ,                                                 \
+        (1)NAME_SEQ,                                                            \
+        struct_tag,                                                             \
+        BOOST_PP_CAT(BOOST_FUSION_ADAPT_CLASS_FILLER_0 ATTRIBUTES,_END),        \
+        BOOST_FUSION_ADAPT_CLASS_C)
 
-#define BOOST_FUSION_ADAPT_CLASS_C(r, fullname, i, xy)                          \
-    template <>                                                                 \
-    struct class_member_proxy<fullname, i>                                      \
-    {                                                                           \
-        typedef BOOST_PP_TUPLE_ELEM(4, 0, xy) lvalue;                           \
-        typedef BOOST_PP_TUPLE_ELEM(4, 1, xy) rvalue;                           \
-        typedef remove_const<remove_reference<lvalue>::type>::type type;        \
-        typedef add_reference<add_const<type>::type>::type cref_type;           \
-                                                                                \
-        class_member_proxy(fullname& obj) : obj(obj) {}                         \
-        fullname& obj;                                                          \
-                                                                                \
-        class_member_proxy& operator=(cref_type val)                            \
-        {                                                                       \
-            BOOST_PP_TUPLE_ELEM(4, 3, xy);                                      \
-            return *this;                                                       \
-        }                                                                       \
-                                                                                \
-        operator lvalue()                                                       \
-        {                                                                       \
-            return BOOST_PP_TUPLE_ELEM(4, 2, xy);                               \
-        }                                                                       \
-    };                                                                          \
-                                                                                \
-    template <>                                                                 \
-    struct class_member<fullname, i>                                            \
-    {                                                                           \
-        typedef class_member_proxy<fullname, i> proxy;                          \
-        typedef proxy::type type;                                               \
-        typedef proxy::rvalue get_type;                                         \
-                                                                                \
-        static get_type call(fullname const& obj)                               \
-        {                                                                       \
-            return BOOST_PP_TUPLE_ELEM(4, 2, xy);                               \
-        }                                                                       \
-                                                                                \
-        static proxy call(fullname& obj)                                        \
-        {                                                                       \
-            return proxy(obj);                                                  \
-        }                                                                       \
-    };                                                                          \
-    /***/
+#define BOOST_FUSION_ADAPT_CLASS(NAME, ATTRIBUTES)                              \
+    BOOST_FUSION_ADAPT_STRUCT_BASE(                                             \
+        (0),                                                                    \
+        (0)(NAME),                                                              \
+        struct_tag,                                                             \
+        BOOST_PP_CAT(BOOST_FUSION_ADAPT_CLASS_FILLER_0 ATTRIBUTES,_END),        \
+        BOOST_FUSION_ADAPT_CLASS_C)
 
 
 #endif

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

@@ -1,156 +1,30 @@
 /*=============================================================================
     Copyright (c) 2001-2009 Joel de Guzman
     Copyright (c) 2009-2010 Hartmut Kaiser
+    Copyright (c) 2010 Christopher Schmidt
 
     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_ADAPT_CLASS_NAMED_JAN_27_2010_0614PM)
-#define BOOST_FUSION_ADAPT_CLASS_NAMED_JAN_27_2010_0614PM
 
-#include <boost/fusion/support/tag_of_fwd.hpp>
-#include <boost/fusion/adapted/class/extension.hpp>
-#include <boost/fusion/adapted/class/class_iterator.hpp>
-#include <boost/fusion/adapted/class/detail/is_view_impl.hpp>
-#include <boost/fusion/adapted/class/detail/is_sequence_impl.hpp>
-#include <boost/fusion/adapted/class/detail/category_of_impl.hpp>
-#include <boost/fusion/adapted/class/detail/begin_impl.hpp>
-#include <boost/fusion/adapted/class/detail/end_impl.hpp>
-#include <boost/fusion/adapted/class/detail/size_impl.hpp>
-#include <boost/fusion/adapted/class/detail/at_impl.hpp>
-#include <boost/fusion/adapted/class/detail/value_at_impl.hpp>
+#ifndef BOOST_FUSION_ADAPTED_CLASS_ADAPT_CLASS_NAMED_HPP
+#define BOOST_FUSION_ADAPTED_CLASS_ADAPT_CLASS_NAMED_HPP
 
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/seq/for_each.hpp>
-#include <boost/preprocessor/seq/for_each_i.hpp>
-#include <boost/preprocessor/tuple/elem.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/config/no_tr1/utility.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
+#include <boost/fusion/adapted/class/adapt_class.hpp>
+#include <boost/fusion/adapted/struct/detail/proxy_type.hpp>
 
-#define BOOST_FUSION_ADAPT_CLASS_NAMED(name, newname, bseq)                     \
-    BOOST_FUSION_ADAPT_CLASS_NAMED_I(name, (boost)(fusion)(adapted), newname,   \
-        BOOST_PP_CAT(BOOST_FUSION_ADAPT_CLASS_NAMED_X bseq, 0))                 \
-    /***/
+#define BOOST_FUSION_ADAPT_CLASS_NAMED_NS(                                      \
+    WRAPPED_TYPE, NAMESPACE_SEQ, NAME, ATTRIBUTES)                              \
+                                                                                \
+    BOOST_FUSION_ADAPT_STRUCT_DEFINE_PROXY_TYPE(                                \
+        WRAPPED_TYPE,(0)NAMESPACE_SEQ,NAME)                                     \
+                                                                                \
+    BOOST_FUSION_ADAPT_CLASS(                                                   \
+        BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION((0)NAMESPACE_SEQ)NAME,  \
+        ATTRIBUTES)
 
-#define BOOST_FUSION_ADAPT_CLASS_NAMED_NS(name, ns, newname, bseq)              \
-    BOOST_FUSION_ADAPT_CLASS_NAMED_I(name, ns, newname,                         \
-        BOOST_PP_CAT(BOOST_FUSION_ADAPT_CLASS_NAMED_X bseq, 0))                 \
-    /***/
-
-#define BOOST_FUSION_ADAPT_CLASS_NAMED_X(w, x, y, z) ((w, x, y, z)) BOOST_FUSION_ADAPT_CLASS_NAMED_Y
-#define BOOST_FUSION_ADAPT_CLASS_NAMED_Y(w, x, y, z) ((w, x, y, z)) BOOST_FUSION_ADAPT_CLASS_NAMED_X
-#define BOOST_FUSION_ADAPT_CLASS_NAMED_X0
-#define BOOST_FUSION_ADAPT_CLASS_NAMED_Y0
-
-// BOOST_FUSION_ADAPT_CLASS_I generates the overarching structure and uses
-// SEQ_FOR_EACH_I to generate the "linear" substructures.
-// Thanks to Paul Mensonides for the PP macro help
-
-#define BOOST_FUSION_ADAPT_CLASS_NAMED_I(name, ns, newname, seq)                \
-    BOOST_PP_SEQ_FOR_EACH_R(1, BOOST_FUSION_ADAPT_CLASS_NAMED_NS_B, _, ns)      \
-        struct newname                                                          \
-        {                                                                       \
-            newname(name& s) : obj(s) {}                                        \
-            name& obj;                                                          \
-        };                                                                      \
-    BOOST_PP_SEQ_FOR_EACH_R(1, BOOST_FUSION_ADAPT_CLASS_NAMED_NS_E, _, ns)      \
-                                                                                \
-    namespace boost { namespace fusion { namespace traits                       \
-    {                                                                           \
-        template <>                                                             \
-        struct tag_of<BOOST_FUSION_ADAPT_CLASS_NAMED_NAME(ns, newname)>         \
-        {                                                                       \
-            typedef class_tag type;                                             \
-        };                                                                      \
-    }}}                                                                         \
-                                                                                \
-    namespace boost { namespace mpl                                             \
-    {                                                                           \
-        template<typename>                                                      \
-        struct sequence_tag;                                                    \
-                                                                                \
-        template<>                                                              \
-        struct sequence_tag<BOOST_FUSION_ADAPT_CLASS_NAMED_NAME(ns, newname)>   \
-        {                                                                       \
-            typedef fusion::fusion_sequence_tag type;                           \
-        };                                                                      \
-                                                                                \
-        template<>                                                              \
-        struct sequence_tag<BOOST_FUSION_ADAPT_CLASS_NAMED_NAME(ns, newname) const> \
-        {                                                                       \
-            typedef fusion::fusion_sequence_tag type;                           \
-        };                                                                      \
-    }}                                                                          \
-                                                                                \
-    namespace boost { namespace fusion { namespace extension                    \
-    {                                                                           \
-        template <>                                                             \
-        struct class_size<BOOST_FUSION_ADAPT_CLASS_NAMED_NAME(ns, newname)>     \
-            : mpl::int_<BOOST_PP_SEQ_SIZE(seq)> {};                             \
-        template <typename T, int N> struct class_member_proxy;                 \
-        BOOST_PP_SEQ_FOR_EACH_I(BOOST_FUSION_ADAPT_CLASS_NAMED_C,               \
-            BOOST_FUSION_ADAPT_CLASS_NAMED_NAME(ns, newname),seq)               \
-    }}}                                                                         \
-    /***/
-
-#define BOOST_FUSION_ADAPT_CLASS_NAMED_NAME(ns, newname)                        \
-    BOOST_PP_SEQ_FOR_EACH_R(1, BOOST_FUSION_ADAPT_CLASS_NAMED_NS_D, _, ns)      \
-    newname                                                                     \
-    /***/
-
-#define BOOST_FUSION_ADAPT_CLASS_NAMED_NS_B(r, _, ns) namespace ns { 
-#define BOOST_FUSION_ADAPT_CLASS_NAMED_NS_D(r, _, ns) ns::
-#define BOOST_FUSION_ADAPT_CLASS_NAMED_NS_E(r, _, ns) }
-
-#define BOOST_FUSION_ADAPT_CLASS_NAMED_C(r, fullname, i, xy)                    \
-    template <>                                                                 \
-    struct class_member_proxy<fullname, i>                                      \
-    {                                                                           \
-        typedef BOOST_PP_TUPLE_ELEM(4, 0, xy) lvalue;                           \
-        typedef BOOST_PP_TUPLE_ELEM(4, 1, xy) rvalue;                           \
-        typedef remove_const<remove_reference<lvalue>::type>::type type;        \
-        typedef add_reference<add_const<type>::type>::type cref_type;           \
-                                                                                \
-        class_member_proxy(fullname& obj) : obj(obj) {}                         \
-        fullname& obj;                                                          \
-                                                                                \
-        class_member_proxy& operator=(cref_type val)                            \
-        {                                                                       \
-            BOOST_PP_TUPLE_ELEM(4, 3, xy);                                      \
-            return *this;                                                       \
-        }                                                                       \
-                                                                                \
-        operator lvalue()                                                       \
-        {                                                                       \
-            return BOOST_PP_TUPLE_ELEM(4, 2, xy);                               \
-        }                                                                       \
-    };                                                                          \
-                                                                                \
-    template <>                                                                 \
-    struct class_member<fullname, i>                                            \
-    {                                                                           \
-        typedef class_member_proxy<fullname, i> proxy;                          \
-        typedef proxy::type type;                                               \
-        typedef proxy::rvalue get_type;                                         \
-                                                                                \
-        static get_type call(fullname const& obj)                               \
-        {                                                                       \
-            return BOOST_PP_TUPLE_ELEM(4, 2, xy);                               \
-        }                                                                       \
-                                                                                \
-        static proxy call(fullname& obj)                                        \
-        {                                                                       \
-            return proxy(obj);                                                  \
-        }                                                                       \
-    };                                                                          \
-    /***/
+#define BOOST_FUSION_ADAPT_CLASS_NAMED(WRAPPED_TYPE, NAME, ATTRIBUTES)          \
+   BOOST_FUSION_ADAPT_CLASS_NAMED_NS(                                           \
+        WRAPPED_TYPE,(boost)(fusion)(adapted),NAME,ATTRIBUTES)
 
 #endif

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

@@ -1,105 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2009 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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(FUSION_CLASS_ITERATOR_OCTOBER_4_2009_839M)
-#define FUSION_CLASS_ITERATOR_OCTOBER_4_2009_839M
-
-#include <boost/fusion/iterator/iterator_facade.hpp>
-#include <boost/fusion/adapted/class/extension.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/minus.hpp>
-#include <boost/config/no_tr1/utility.hpp>
-
-namespace boost { namespace fusion
-{
-    struct random_access_traversal_tag;
-
-    template <typename Class, int N_>
-    struct class_iterator
-        : iterator_facade<class_iterator<Class, N_>, random_access_traversal_tag>
-    {
-        BOOST_MPL_ASSERT_RELATION(N_, >=, 0);
-        BOOST_MPL_ASSERT_RELATION(N_, <=, extension::class_size<Class>::value);
-
-        typedef mpl::int_<N_> index;
-        typedef Class class_type;
-
-        class_iterator(Class& class_)
-            : class_(class_) {}
-        Class& class_;
-
-        template <typename Iterator>
-        struct value_of
-            : extension::class_member<Class, N_>
-        {
-        };
-
-        template <typename Iterator>
-        struct deref
-        {
-            typedef typename
-                mpl::if_<
-                    is_const<Class>
-                  , typename extension::class_member<Class, N_>::get_type
-                  , typename extension::class_member<Class, N_>::proxy
-                >::type
-            type;
-
-            static type
-            call(Iterator const& iter)
-            {
-                return extension::class_member<Class, N_>::
-                    call(iter.class_);
-            }
-        };
-
-        template <typename Iterator, typename N>
-        struct advance
-        {
-            typedef typename Iterator::index index;
-            typedef typename Iterator::class_type class_type;
-            typedef class_iterator<class_type, index::value + N::value> type;
-
-            static type
-            call(Iterator const& iter)
-            {
-                return type(iter.class_);
-            }
-        };
-
-        template <typename Iterator>
-        struct next : advance<Iterator, mpl::int_<1> > {};
-
-        template <typename Iterator>
-        struct prior : advance<Iterator, mpl::int_<-1> > {};
-
-        template <typename I1, typename I2>
-        struct distance : mpl::minus<typename I2::index, typename I1::index>
-        {
-            typedef typename
-                mpl::minus<
-                    typename I2::index, typename I1::index
-                >::type
-            type;
-
-            static type
-            call(I1 const&, I2 const&)
-            {
-                return type();
-            }
-        };
-    };
-}}
-
-#endif
-
-

include/boost/fusion/adapted/class/detail/adapt_base.hpp

@@ -0,0 +1,115 @@
+/*=============================================================================
+    Copyright (c) 2001-2009 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ADAPTED_CLASS_DETAIL_ADAPT_BASE_HPP
+#define BOOST_FUSION_ADAPTED_CLASS_DETAIL_ADAPT_BASE_HPP
+
+#include <boost/preprocessor/control/if.hpp>
+#include <boost/preprocessor/seq/seq.hpp>
+#include <boost/preprocessor/seq/elem.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+//cschmidt: Spirit relies on Fusion defining class_member_proxy in the
+//boost::fusion::extension namespace, with two nested types named lvalue and
+//rvalue.
+
+#define BOOST_FUSION_ADAPT_CLASS_GET_IDENTITY_TEMPLATE_IMPL(TEMPLATE_PARAMS_SEQ)\
+    typename detail::get_identity<                                              \
+        lvalue                                                                  \
+      , BOOST_PP_SEQ_ELEM(1,TEMPLATE_PARAMS_SEQ)                                \
+    >::type
+
+#define BOOST_FUSION_ADAPT_CLASS_GET_IDENTITY_NON_TEMPLATE_IMPL(                \
+    TEMPLATE_PARAMS_SEQ)                                                        \
+                                                                                \
+    lvalue
+
+#define BOOST_FUSION_ADAPT_CLASS_C_BASE(\
+    TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,ATTRIBUTE,ATTRIBUTE_TUPEL_SIZE)              \
+                                                                                \
+    template<                                                                   \
+        BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
+    >                                                                           \
+    struct class_member_proxy<                                                  \
+        BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                         \
+      , I                                                                       \
+    >                                                                           \
+    {                                                                           \
+        typedef BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 0, ATTRIBUTE) lvalue; \
+        typedef BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 1, ATTRIBUTE) rvalue; \
+                                                                                \
+        class_member_proxy(BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj)\
+          : obj(obj)                                                            \
+        {}                                                                      \
+                                                                                \
+        template<class Arg>                                                     \
+        class_member_proxy&                                                     \
+        operator=(Arg const& val)                                               \
+        {                                                                       \
+            BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 3, ATTRIBUTE);            \
+            return *this;                                                       \
+        }                                                                       \
+                                                                                \
+        operator lvalue()                                                       \
+        {                                                                       \
+            return BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 2, ATTRIBUTE);     \
+        }                                                                       \
+                                                                                \
+        BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj;                   \
+    };                                                                          \
+                                                                                \
+    template<                                                                   \
+        BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
+    >                                                                           \
+    struct struct_member<BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ), I>    \
+    {                                                                           \
+        typedef BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 0, ATTRIBUTE) lvalue; \
+                                                                                \
+        typedef                                                                 \
+            BOOST_PP_IF(                                                        \
+                BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ),                         \
+                BOOST_FUSION_ADAPT_CLASS_GET_IDENTITY_TEMPLATE_IMPL,            \
+                BOOST_FUSION_ADAPT_CLASS_GET_IDENTITY_NON_TEMPLATE_IMPL)(       \
+                    TEMPLATE_PARAMS_SEQ)                                        \
+        type;                                                                   \
+                                                                                \
+        template<typename Seq>                                                  \
+        struct apply                                                            \
+        {                                                                       \
+            typedef                                                             \
+                class_member_proxy<                                             \
+                    BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)             \
+                  , I                                                           \
+                >                                                               \
+            proxy;                                                              \
+                                                                                \
+            typedef typename                                                    \
+                mpl::if_<                                                       \
+                    is_const<Seq>                                               \
+                  , BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 1, ATTRIBUTE)     \
+                  , proxy                                                       \
+                >::type                                                         \
+            type;                                                               \
+                                                                                \
+            static proxy                                                        \
+            call(BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj)          \
+            {                                                                   \
+                return proxy(obj);                                              \
+            }                                                                   \
+                                                                                \
+            static BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 1, ATTRIBUTE)      \
+            call(BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) const& obj)    \
+            {                                                                   \
+                return BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 2, ATTRIBUTE); \
+            }                                                                   \
+        };                                                                      \
+    };
+
+#endif

include/boost/fusion/adapted/class/detail/at_impl.hpp

@@ -1,70 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2009 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_AT_IMPL_OCTOBER_4_2009_920PM)
-#define BOOST_FUSION_AT_IMPL_OCTOBER_4_2009_920PM
-
-#include <boost/fusion/support/detail/access.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/int.hpp>
-
-namespace boost { namespace fusion
-{
-    struct class_tag;
-
-    namespace extension
-    {
-        template<typename T>
-        struct at_impl;
-
-        template <typename Class, int N>
-        struct class_member;
-
-        template <typename Class>
-        struct class_size;
-
-        template <>
-        struct at_impl<class_tag>
-        {
-            template <typename Sequence, typename N>
-            struct apply
-            {
-                static int const n_value = N::value;
-                BOOST_MPL_ASSERT_RELATION(
-                    n_value, <=, extension::class_size<Sequence>::value);
-
-                typedef typename
-                    extension::class_member<Sequence, N::value>
-                element;
-
-                typedef typename
-                    mpl::if_<
-                        is_const<Sequence>
-                      , typename class_member<Sequence, N::value>::get_type
-                      , typename class_member<Sequence, N::value>::proxy
-                    >::type
-                type;
-
-                static type
-                call(Sequence& seq)
-                {
-                    return extension::
-                        class_member<Sequence, N::value>::call(seq);
-                }
-                
-                //~ static typename class_member<Sequence, N::value>::get_type
-                //~ call(Sequence const& seq)
-                //~ {
-                    //~ return extension::
-                        //~ class_member<Sequence, N::value>::call(seq);
-                //~ }
-            };
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/class/detail/at_key_impl.hpp

@@ -1,54 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2009 Joel de Guzman
-    Copyright (c) 2005-2007 Dan Marsden
-
-    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_AT_KEY_IMPL_OCTOBER_4_2009_920PM)
-#define BOOST_FUSION_AT_KEY_IMPL_OCTOBER_4_2009_920PM
-
-#include <boost/fusion/support/detail/access.hpp>
-
-namespace boost { namespace fusion
-{
-    struct class_tag;
-
-    namespace extension
-    {
-        template<typename T>
-        struct at_key_impl;
-
-        template <typename Class, typename Key>
-        struct class_assoc_member;
-
-        template <>
-        struct at_key_impl<class_tag>
-        {
-            template <typename Sequence, typename Key>
-            struct apply
-            {
-                typedef typename
-                extension::class_assoc_member<Sequence, Key>
-                element;
-
-                typedef typename
-                    mpl::eval_if<
-                        is_const<Sequence>
-                      , detail::cref_result<element>
-                      , detail::ref_result<element>
-                    >::type
-                type;
-
-                static type
-                call(Sequence& seq)
-                {
-                    return extension::
-                        class_assoc_member<Sequence, Key>::call(seq);
-                }
-            };
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/class/detail/begin_impl.hpp

@@ -1,40 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2009 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_BEGIN_IMPL_OCTOBER_4_2009_920PM)
-#define BOOST_FUSION_BEGIN_IMPL_OCTOBER_4_2009_920PM
-
-#include <boost/fusion/adapted/class/class_iterator.hpp>
-
-namespace boost { namespace fusion
-{
-    struct class_tag;
-
-    namespace extension
-    {
-        template<typename T>
-        struct begin_impl;
-
-        template <>
-        struct begin_impl<class_tag>
-        {
-            template <typename Sequence>
-            struct apply
-            {
-                typedef class_iterator<Sequence, 0> type;
-
-                static type
-                call(Sequence& v)
-                {
-                    return type(v);
-                }
-            };
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/class/detail/category_of_impl.hpp

@@ -1,35 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2009 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_CATEGORY_OF_IMPL_OCTOBER_4_2009_919PM)
-#define BOOST_FUSION_CATEGORY_OF_IMPL_OCTOBER_4_2009_919PM
-
-#include <boost/config/no_tr1/utility.hpp>
-
-namespace boost { namespace fusion
-{
-    struct class_tag;
-    struct random_access_traversal_tag;
-
-    namespace extension
-    {
-        template<typename T>
-        struct category_of_impl;
-
-        template<>
-        struct category_of_impl<class_tag>
-        {
-            template<typename T>
-            struct apply
-            {
-                typedef random_access_traversal_tag type;
-            };
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/class/detail/end_impl.hpp

@@ -1,48 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2009 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_END_IMPL_OCTOBER_4_2009_919PM)
-#define BOOST_FUSION_END_IMPL_OCTOBER_4_2009_919PM
-
-#include <boost/fusion/adapted/class/class_iterator.hpp>
-
-namespace boost { namespace fusion
-{
-    struct class_tag;
-
-    namespace extension
-    {
-        template <typename Tag>
-        struct end_impl;
-
-        template <typename Class>
-        struct class_size;
-
-        template <>
-        struct end_impl<class_tag>
-        {
-            template <typename Sequence>
-            struct apply
-            {
-                typedef
-                    class_iterator<
-                        Sequence
-                      , class_size<Sequence>::value
-                    >
-                type;
-
-                static type
-                call(Sequence& v)
-                {
-                    return type(v);
-                }
-            };
-        };
-    }
-}}
-
-#endif

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

@@ -1,36 +1,32 @@
 /*=============================================================================
     Copyright (c) 2001-2009 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2010 Christopher Schmidt
 
     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_SIZE_IMPL_OCTOBER_4_2009_919PM)
-#define BOOST_FUSION_SIZE_IMPL_OCTOBER_4_2009_919PM
 
-#include <boost/mpl/int.hpp>
+#ifndef BOOST_FUSION_ADAPTED_CLASS_DETAIL_EXTENSION_HPP
+#define BOOST_FUSION_ADAPTED_CLASS_DETAIL_EXTENSION_HPP
+
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 
 namespace boost { namespace fusion
 {
-    namespace extension
+    namespace detail
     {
-        template <typename Class>
-        struct class_size;
+        template <typename T, typename Dummy>
+        struct get_identity
+          : remove_const<typename remove_reference<T>::type>
+        {};
     }
 
-    struct class_tag;
-
     namespace extension
     {
-        template<typename T>
-        struct size_impl;
-
-        template <>
-        struct size_impl<class_tag>
-        {
-            template <typename Sequence>
-            struct apply : extension::class_size<Sequence> {};
-        };
+        template <typename T, int N>
+        struct class_member_proxy;
     }
 }}
 

include/boost/fusion/adapted/class/detail/has_key_impl.hpp

@@ -1,40 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2009 Joel de Guzman
-    Copyright (c) 2005-2007 Dan Marsden
-
-    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_HAS_KEY_IMPL_OCTOBER_4_2009_919PM)
-#define BOOST_FUSION_HAS_KEY_IMPL_OCTOBER_4_2009_919PM
-
-#include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/not.hpp>
-
-namespace boost { namespace fusion {
-
-    struct class_tag;
-
-    namespace extension
-    {
-        struct no_such_member;
-
-        template<typename T>
-        struct has_key_impl;
-
-        template<typename Class, typename Key>
-        struct class_assoc_member;
-
-        template<>
-        struct has_key_impl<class_tag>
-        {
-            template<typename Sequence, typename Key>
-            struct apply
-                : mpl::not_<is_same<no_such_member, typename class_assoc_member<Sequence, Key>::type> >
-            {
-            };
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/class/detail/is_sequence_impl.hpp

@@ -1,31 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2009 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_IS_SEQUENCE_IMPL_OCTOBER_4_2009_919PM)
-#define BOOST_FUSION_IS_SEQUENCE_IMPL_OCTOBER_4_2009_919PM
-
-#include <boost/mpl/bool.hpp>
-
-namespace boost { namespace fusion
-{
-    struct class_tag;
-
-    namespace extension
-    {
-        template<typename Tag>
-        struct is_sequence_impl;
-
-        template<>
-        struct is_sequence_impl<class_tag>
-        {
-            template<typename Sequence>
-            struct apply : mpl::true_ {};
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/class/detail/is_view_impl.hpp

@@ -1,32 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2009 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_IS_VIEW_IMPL_OCTOBER_4_2009_919PM)
-#define BOOST_FUSION_IS_VIEW_IMPL_OCTOBER_4_2009_919PM
-
-#include <boost/mpl/bool.hpp>
-
-namespace boost { namespace fusion
-{
-    struct class_tag;
-
-    namespace extension
-    {
-        template<typename Tag>
-        struct is_view_impl;
-
-        template<>
-        struct is_view_impl<class_tag>
-        {
-            template<typename T>
-            struct apply : mpl::false_
-            {};
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/class/detail/value_at_impl.hpp

@@ -1,47 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2009 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_VALUE_AT_IMPL_OCTOBER_4_2009_918PM)
-#define BOOST_FUSION_VALUE_AT_IMPL_OCTOBER_4_2009_918PM
-
-#include <boost/mpl/if.hpp>
-#include <boost/static_assert.hpp>
-
-namespace boost { namespace fusion
-{
-    struct class_tag;
-
-    namespace extension
-    {
-        template<typename T>
-        struct value_at_impl;
-
-        template <typename Class, int N>
-        struct class_member;
-
-        template <typename Class>
-        struct class_size;
-
-        template <>
-        struct value_at_impl<class_tag>
-        {
-            template <typename Sequence, typename N>
-            struct apply
-            {
-                static int const n_value = N::value;
-                BOOST_MPL_ASSERT_RELATION(
-                    n_value, <=, extension::class_size<Sequence>::value);
-
-                typedef typename
-                    extension::class_member<Sequence, N::value>::type
-                type;
-            };
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/class/detail/value_at_key_impl.hpp

@@ -1,39 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2009 Joel de Guzman
-    Copyright (c) 2005-2007 Dan Marsden
-
-    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_VALUE_AT_KEY_IMPL_OCTOBER_4_2009_918PM)
-#define BOOST_FUSION_VALUE_AT_KEY_IMPL_OCTOBER_4_2009_918PM
-
-#include <boost/mpl/if.hpp>
-
-namespace boost { namespace fusion
-{
-    struct class_tag;
-
-    namespace extension
-    {
-        template<typename T>
-        struct value_at_key_impl;
-
-        template <typename Class, typename Key>
-        struct class_assoc_member;
-
-        template <>
-        struct value_at_key_impl<class_tag>
-        {
-            template <typename Sequence, typename Key>
-            struct apply
-            {
-                typedef typename
-                    extension::class_assoc_member<Sequence, Key>::type
-                type;
-            };
-        };
-    }
-}}
-
-#endif

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

@@ -1,61 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2009 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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(FUSION_CLASS_EXTENSION_OCTOBER_4_2009_839PM)
-#define FUSION_CLASS_EXTENSION_OCTOBER_4_2009_839PM
-
-#include <boost/type_traits/add_const.hpp>
-
-namespace boost { namespace fusion
-{
-    struct fusion_sequence_tag;
-
-    namespace extension
-    {
-        template <typename Class, int N>
-        struct class_member;
-
-        template <typename Class>
-        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, 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

@@ -1,89 +1,24 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
 
     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_STD_PAIR_24122005_1744)
-#define BOOST_FUSION_STD_PAIR_24122005_1744
 
-#include <boost/fusion/support/tag_of_fwd.hpp>
-#include <boost/fusion/adapted/struct.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/config/no_tr1/utility.hpp>
+#ifndef BOOST_FUSION_ADAPTED_STD_PAIR_HPP
+#define BOOST_FUSION_ADAPTED_STD_PAIR_HPP
 
-namespace boost { namespace fusion
+#include <boost/fusion/adapted/struct/adapt_struct.hpp>
+
+namespace std
 {
-    struct struct_tag;
-    struct fusion_sequence_tag;
+    template<class T1, class T2>
+    struct pair;
+}
 
-    namespace traits
-    {
-        template <typename T1, typename T2>
-#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
-        struct tag_of<std::pair<T1, T2>, void >
-#else
-        struct tag_of<std::pair<T1, T2> >
-#endif
-        {
-            typedef struct_tag type;
-        };
-    }
-}}
-
-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>
-    {
-    };
-}}}
+BOOST_FUSION_ADAPT_TPL_STRUCT(
+    (T1)(T2),(std::pair)(T1)(T2),(T1, first)(T2, second))
 
 #endif

include/boost/fusion/adapted/std_pair/detail/at_impl.hpp

@@ -1,71 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2006 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_AT_IMPL_24122005_1807)
-#define BOOST_FUSION_AT_IMPL_24122005_1807
-
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/fusion/support/detail/access.hpp>
-
-namespace boost { namespace fusion {
-
-    struct std_pair_tag;
-
-    namespace extension
-    {
-        template<typename T>
-        struct at_impl;
-
-        template <>
-        struct at_impl<std_pair_tag>
-        {
-            template <typename Sequence, typename N>
-            struct apply 
-            {
-                static int const n_value = N::value;
-                BOOST_STATIC_ASSERT((n_value >= 0 && n_value < 2));
-                typedef typename
-                    mpl::if_c<
-                        (n_value == 0)
-                      , typename Sequence::first_type
-                      , typename Sequence::second_type
-                    >
-                element;
-
-                typedef typename
-                    mpl::eval_if<
-                        is_const<Sequence>
-                      , detail::cref_result<element>
-                      , detail::ref_result<element>
-                    >::type
-                type;
-
-                template <typename RT>
-                static RT get(Sequence& p, mpl::int_<0>)
-                {
-                    return  p.first;
-                }
-
-                template <typename RT>
-                static RT get(Sequence& p, mpl::int_<1>)
-                {
-                    return  p.second;
-                }
-
-                static type
-                call(Sequence& p)
-                {
-                    return get<type>(p, N());
-                }
-            };
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/std_pair/detail/begin_impl.hpp

@@ -1,40 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2006 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_BEGIN_IMPL_24122005_1752)
-#define BOOST_FUSION_BEGIN_IMPL_24122005_1752
-
-#include <boost/fusion/adapted/std_pair/std_pair_iterator.hpp>
-
-namespace boost { namespace fusion {
-
-    struct std_pair_tag;
-
-    namespace extension
-    {
-        template<typename T>
-        struct begin_impl;
-
-        template <>
-        struct begin_impl<std_pair_tag>
-        {
-            template <typename Sequence>
-            struct apply 
-            {
-                typedef std_pair_iterator<Sequence, 0> type;
-    
-                static type
-                call(Sequence& v)
-                {
-                    return type(v);
-                }
-            };
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/std_pair/detail/category_of_impl.hpp

@@ -1,35 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2006 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_CATEGORY_OF_IMPL_24122005_1731)
-#define BOOST_FUSION_CATEGORY_OF_IMPL_24122005_1731
-
-#include <boost/config/no_tr1/utility.hpp>
-
-namespace boost { namespace fusion { 
-
-    struct std_pair_tag;
-    struct random_access_traversal_tag;
-
-    namespace extension
-    {
-        template<typename T>
-        struct category_of_impl;
-
-        template<>
-        struct category_of_impl<std_pair_tag>
-        {
-            template<typename T>
-            struct apply
-            {
-                typedef random_access_traversal_tag type;
-            };
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/std_pair/detail/end_impl.hpp

@@ -1,40 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2006 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_END_IMPL_24122005_1755)
-#define BOOST_FUSION_END_IMPL_24122005_1755
-
-#include <boost/fusion/adapted/std_pair/std_pair_iterator.hpp>
-
-namespace boost { namespace fusion {
-
-    struct std_pair_tag;
-
-    namespace extension
-    {
-        template <typename Tag>
-        struct end_impl;
-
-        template <>
-        struct end_impl<std_pair_tag>
-        {
-            template <typename Sequence>
-            struct apply 
-            {
-                typedef std_pair_iterator<Sequence, 2> type;
-    
-                static type
-                call(Sequence& v)
-                {
-                    return type(v);
-                }
-            };
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/std_pair/detail/is_sequence_impl.hpp

@@ -1,31 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2006 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_IS_SEQUENCE_IMPL_27122005_1651)
-#define BOOST_FUSION_IS_SEQUENCE_IMPL_27122005_1651
-
-#include <boost/mpl/bool.hpp>
-
-namespace boost { namespace fusion {
-
-    struct std_pair_tag;
-
-    namespace extension
-    {
-        template<typename Tag>
-        struct is_sequence_impl;
-
-        template<>
-        struct is_sequence_impl<std_pair_tag>
-        {
-            template<typename Sequence>
-            struct apply : mpl::true_ {};
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/std_pair/detail/is_view_impl.hpp

@@ -1,32 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2006 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_IS_VIEW_IMPL_27042006_2219)
-#define BOOST_FUSION_IS_VIEW_IMPL_27042006_2219
-
-#include <boost/mpl/bool.hpp>
-
-namespace boost { namespace fusion 
-{
-    struct std_pair_tag;
-
-    namespace extension
-    {
-        template<typename Tag>
-        struct is_view_impl;
-
-        template<>
-        struct is_view_impl<std_pair_tag>
-        {
-            template<typename T>
-            struct apply : mpl::false_
-            {};
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/std_pair/detail/size_impl.hpp

@@ -1,31 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2006 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_SIZE_IMPL_24122005_1759)
-#define BOOST_FUSION_SIZE_IMPL_24122005_1759
-
-#include <boost/mpl/int.hpp>
-
-namespace boost { namespace fusion {
-
-    struct std_pair_tag;
-
-    namespace extension
-    {
-        template<typename T>
-        struct size_impl;
-
-        template <>
-        struct size_impl<std_pair_tag>
-        {
-            template <typename Sequence>
-            struct apply : mpl::int_<2> {};
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/std_pair/detail/value_at_impl.hpp

@@ -1,43 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2006 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_VALUE_AT_IMPL_24122005_1917)
-#define BOOST_FUSION_VALUE_AT_IMPL_24122005_1917
-
-#include <boost/mpl/if.hpp>
-#include <boost/static_assert.hpp>
-
-namespace boost { namespace fusion {
-
-    struct std_pair_tag;
-
-    namespace extension
-    {
-        template<typename T>
-        struct value_at_impl;
-
-        template <>
-        struct value_at_impl<std_pair_tag>
-        {
-            template <typename Sequence, typename N>
-            struct apply 
-            {
-                static int const n_value = N::value;
-                BOOST_STATIC_ASSERT((n_value >= 0 && n_value < 2));
-                typedef typename
-                    mpl::if_c<
-                        (n_value == 0)
-                      , typename Sequence::first_type
-                      , typename Sequence::second_type
-                    >::type
-                type;
-            };
-        };
-    }
-}}
-
-#endif

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

@@ -1,127 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2006 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)
-==============================================================================*/
-#if !defined(FUSION_STD_PAIR_ITERATOR_09262005_0934)
-#define FUSION_STD_PAIR_ITERATOR_09262005_0934
-
-#include <boost/fusion/iterator/iterator_facade.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/minus.hpp>
-#include <boost/config/no_tr1/utility.hpp>
-
-namespace boost { namespace fusion
-{
-    struct random_access_traversal_tag;
-
-    template <typename Pair_, int N_>
-    struct std_pair_iterator
-        : iterator_facade<std_pair_iterator<Pair_, N_>, random_access_traversal_tag>
-    {
-        BOOST_MPL_ASSERT_RELATION(N_, >=, 0);
-        BOOST_MPL_ASSERT_RELATION(N_, <=, 2);
-
-        typedef mpl::int_<N_> index;
-        typedef Pair_ pair_type;
-
-        std_pair_iterator(Pair_& pair)
-            : pair(pair) {}
-        Pair_& pair;
-
-        template <typename Iterator>
-        struct value_of;
-
-        template <typename Pair>
-        struct value_of<std_pair_iterator<Pair, 0> >
-            : mpl::identity<typename Pair::first_type> {};
-
-        template <typename Pair>
-        struct value_of<std_pair_iterator<Pair, 1> >
-            : mpl::identity<typename Pair::second_type> {};
-
-        template <typename Iterator>
-        struct deref;
-
-        template <typename Pair>
-        struct deref<std_pair_iterator<Pair, 0> >
-        {
-            typedef typename
-                mpl::if_<
-                    is_const<Pair>
-                  , typename Pair::first_type const&
-                  , typename Pair::first_type&
-                >::type
-            type;
-
-            static type
-            call(std_pair_iterator<Pair, 0> const& iter)
-            {
-                return iter.pair.first;
-            }
-        };
-
-        template <typename Pair>
-        struct deref<std_pair_iterator<Pair, 1> >
-        {
-            typedef typename
-                mpl::if_<
-                    is_const<Pair>
-                  , typename Pair::second_type const&
-                  , typename Pair::second_type&
-                >::type
-            type;
-
-            static type
-            call(std_pair_iterator<Pair, 1> const& iter)
-            {
-                return iter.pair.second;
-            }
-        };
-
-        template <typename Iterator, typename N>
-        struct advance
-        {
-            typedef typename Iterator::index index;
-            typedef typename Iterator::pair_type pair_type;
-            typedef std_pair_iterator<pair_type, index::value + N::value> type;
-
-            static type
-            call(Iterator const& iter)
-            {
-                return type(iter.pair);
-            }
-        };
-
-        template <typename Iterator>
-        struct next : advance<Iterator, mpl::int_<1> > {};
-
-        template <typename Iterator>
-        struct prior : advance<Iterator, mpl::int_<-1> > {};
-
-        template <typename I1, typename I2>
-        struct distance : mpl::minus<typename I2::index, typename I1::index>
-        {
-            typedef typename
-                mpl::minus<
-                    typename I2::index, typename I1::index
-                >::type 
-            type;
-
-            static type
-            call(I1 const&, I2 const&)
-            {
-                return type();
-            }
-        };
-    };
-}}
-
-#endif
-
-

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

@@ -1,48 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2006 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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_TAG_OF_24122005_1722)
-#define BOOST_FUSION_TAG_OF_24122005_1722
-
-#include <boost/fusion/support/tag_of_fwd.hpp>
-
-#include <boost/config/no_tr1/utility.hpp>
-
-namespace boost { namespace fusion {
-
-    struct std_pair_tag;
-    struct fusion_sequence_tag;
-
-    namespace traits
-    {
-        template<typename T1, typename T2>
-        struct tag_of<std::pair<T1, T2> >
-        {
-            typedef std_pair_tag type;
-        };
-    }
-}}
-
-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.hpp

@@ -1,29 +1,18 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
 
     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_STRUCT_24122005_1744)
-#define BOOST_FUSION_STRUCT_24122005_1744
 
-#include <boost/fusion/adapted/struct/extension.hpp>
-#include <boost/fusion/adapted/struct/adapt_struct.hpp>
-#include <boost/fusion/adapted/struct/adapt_struct_named.hpp>
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_HPP
+
+#include <boost/fusion/adapted/struct/adapt_assoc_struct_named.hpp>
 #include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp>
-#include <boost/fusion/adapted/struct/struct_iterator.hpp>
-
-#include <boost/fusion/adapted/struct/detail/at_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/at_key_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/begin_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/category_of_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/end_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/has_key_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/is_sequence_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/is_view_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/size_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/value_at_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/value_at_key_impl.hpp>
+#include <boost/fusion/adapted/struct/adapt_struct_named.hpp>
+#include <boost/fusion/adapted/struct/adapt_struct.hpp>
 
 #endif

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

@@ -1,113 +1,82 @@
 /*=============================================================================
     Copyright (c) 2001-2007 Joel de Guzman
     Copyright (c) 2007 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
 
     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_ADAPT_ASSOC_STRUCT_20070508_2207)
-#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_20070508_2207
 
-#include <boost/fusion/support/tag_of_fwd.hpp>
-#include <boost/fusion/adapted/struct/extension.hpp>
-#include <boost/fusion/adapted/struct/struct_iterator.hpp>
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_ADAPT_ASSOC_STRUCT_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_ADAPT_ASSOC_STRUCT_HPP
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/empty.hpp>
+#include <boost/preprocessor/tuple/elem.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+#include <boost/fusion/adapted/struct/detail/extension.hpp>
+#include <boost/fusion/adapted/struct/detail/adapt_base.hpp>
+#include <boost/fusion/adapted/struct/detail/at_impl.hpp>
 #include <boost/fusion/adapted/struct/detail/is_view_impl.hpp>
 #include <boost/fusion/adapted/struct/detail/is_sequence_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/value_at_impl.hpp>
 #include <boost/fusion/adapted/struct/detail/category_of_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/size_impl.hpp>
 #include <boost/fusion/adapted/struct/detail/begin_impl.hpp>
 #include <boost/fusion/adapted/struct/detail/end_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/size_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/at_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/value_at_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/has_key_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/at_key_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/value_at_key_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/value_of_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/deref_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/deref_data_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/key_of_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/value_of_data_impl.hpp>
 
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/seq/for_each_i.hpp>
-#include <boost/preprocessor/tuple/elem.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/config/no_tr1/utility.hpp>
+#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0(X, Y, Z)\
+    ((X, Y, Z)) BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_1
+#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_1(X, Y, Z)\
+    ((X, Y, Z)) BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0
+#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0_END
+#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_1_END
 
-namespace boost { namespace fusion { namespace extension {
-    template<typename Struct, typename Key>
-    struct struct_assoc_member;
-}}}
-
-
-#define BOOST_FUSION_ADAPT_ASSOC_STRUCT(name, bseq)                                   \
-    BOOST_FUSION_ADAPT_ASSOC_STRUCT_I(                                                \
-        name, BOOST_PP_CAT(BOOST_FUSION_ADAPT_ASSOC_STRUCT_X bseq, 0))                \
-    /***/
-
-#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_X(x, y, z) ((x, y, z)) BOOST_FUSION_ADAPT_ASSOC_STRUCT_Y
-#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_Y(x, y, z) ((x, y, z)) BOOST_FUSION_ADAPT_ASSOC_STRUCT_X
-#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_X0
-#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_Y0
-
-// BOOST_FUSION_ADAPT_ASSOC_STRUCT_I generates the overarching structure and uses
-// SEQ_FOR_EACH_I to generate the "linear" substructures.
-// Thanks to Paul Mensonides for the PP macro help
-
-#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_I(name, seq)                            \
-    namespace boost { namespace fusion { namespace traits                       \
-    {                                                                           \
-        template <>                                                             \
-        struct tag_of<name>                                                     \
-        {                                                                       \
-            typedef struct_tag type;                                            \
-        };                                                                      \
-    }}}                                                                         \
+#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_C_BASE(                                 \
+    TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,PREFIX,ATTRIBUTE)                            \
                                                                                 \
-    namespace boost { namespace mpl                                             \
-    {                                                                           \
-        template<typename>                                                      \
-        struct sequence_tag;                                                    \
+    BOOST_FUSION_ADAPT_STRUCT_C_BASE(                                           \
+        TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, PREFIX, ATTRIBUTE, 3)                 \
                                                                                 \
-        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<                                                                   \
+        BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
+    >                                                                           \
+    struct struct_assoc_key<BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ), I> \
     {                                                                           \
-        template <>                                                             \
-        struct struct_size<name> : mpl::int_<BOOST_PP_SEQ_SIZE(seq)> {};        \
-        BOOST_PP_SEQ_FOR_EACH_I(BOOST_FUSION_ADAPT_ASSOC_STRUCT_C, name, seq)   \
-    }}}                                                                         \
-    /***/
-
-#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_C(r, name, i, xy)                       \
-    template <>                                                                 \
-    struct struct_member<name, i>                                               \
-    {                                                                           \
-        typedef BOOST_PP_TUPLE_ELEM(3, 0, xy) type;                             \
-        static type& call(name& struct_)                                        \
-        {                                                                       \
-            return struct_.BOOST_PP_TUPLE_ELEM(3, 1, xy);                       \
-        };                                                                      \
-    };                                                                          \
-    template<>                                                                  \
-    struct struct_assoc_member<name, BOOST_PP_TUPLE_ELEM(3, 2, xy)>             \
-    {                                                                           \
-        typedef BOOST_PP_TUPLE_ELEM(3, 0, xy) type;                             \
-        static type& call(name& struct_)                                        \
-        {                                                                       \
-            return struct_.BOOST_PP_TUPLE_ELEM(3, 1, xy);                       \
-        };                                                                      \
+        typedef BOOST_PP_TUPLE_ELEM(3, 2, ATTRIBUTE) type;                      \
     };
-    /***/
+
+#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_C(                                      \
+    TEMPLATE_PARAMS_SEQ,NAME_SEQ, I, ATTRIBUTE)                                 \
+                                                                                \
+    BOOST_FUSION_ADAPT_ASSOC_STRUCT_C_BASE(                                     \
+        TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,BOOST_PP_EMPTY(),ATTRIBUTE)
+
+#define BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT(                                    \
+    TEMPLATE_PARAMS_SEQ, NAME_SEQ, ATTRIBUTES)                                  \
+                                                                                \
+    BOOST_FUSION_ADAPT_STRUCT_BASE(                                             \
+        (1)TEMPLATE_PARAMS_SEQ,                                                 \
+        (1)NAME_SEQ,                                                            \
+        assoc_struct_tag,                                                       \
+        BOOST_PP_CAT(BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0 ATTRIBUTES,_END), \
+        BOOST_FUSION_ADAPT_ASSOC_STRUCT_C)
+
+#define BOOST_FUSION_ADAPT_ASSOC_STRUCT(NAME, ATTRIBUTES)                       \
+    BOOST_FUSION_ADAPT_STRUCT_BASE(                                             \
+        (0),                                                                    \
+        (0)(NAME),                                                              \
+        assoc_struct_tag,                                                       \
+        BOOST_PP_CAT(BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0 ATTRIBUTES,_END), \
+        BOOST_FUSION_ADAPT_ASSOC_STRUCT_C)
 
 #endif

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

@@ -0,0 +1,38 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_ADAPT_ASSOC_STRUCT_NAMED_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_ADAPT_ASSOC_STRUCT_NAMED_HPP
+
+#include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp>
+#include <boost/fusion/adapted/struct/detail/proxy_type.hpp>
+
+#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_C(                                \
+    TEMPLATE_PARAMS_SEQ,NAME_SEQ, I, ATTRIBUTE)                                 \
+                                                                                \
+    BOOST_FUSION_ADAPT_ASSOC_STRUCT_C_BASE(                                     \
+        TEMPLATE_PARAMS_SEQ,NAME_SEQ, I, obj., ATTRIBUTE)
+
+#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_NS(                               \
+    WRAPPED_TYPE, NAMESPACE_SEQ, NAME, ATTRIBUTES)                              \
+                                                                                \
+    BOOST_FUSION_ADAPT_STRUCT_DEFINE_PROXY_TYPE(                                \
+        WRAPPED_TYPE,(0)NAMESPACE_SEQ,NAME)                                     \
+                                                                                \
+    BOOST_FUSION_ADAPT_STRUCT_BASE(                                             \
+        (0),                                                                    \
+        (0)(BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION(                    \
+            (0)NAMESPACE_SEQ)NAME),                                             \
+        assoc_struct_tag,                                                       \
+        BOOST_PP_CAT(BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0 ATTRIBUTES,_END), \
+        BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_C)
+
+#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(WRAPPED_TYPE, NAME, ATTRIBUTES)   \
+    BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_NS(                                   \
+        WRAPPED_TYPE,(boost)(fusion)(adapted),NAME,ATTRIBUTES)
+
+#endif

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

@@ -1,94 +1,59 @@
 /*=============================================================================
     Copyright (c) 2001-2007 Joel de Guzman
+    Copyright (c) 2009-2010 Christopher Schmidt
 
     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_ADAPT_STRUCT_APRIL_2_2007_1158AM)
-#define BOOST_FUSION_ADAPT_STRUCT_APRIL_2_2007_1158AM
 
-#include <boost/fusion/support/tag_of_fwd.hpp>
-#include <boost/fusion/adapted/struct/extension.hpp>
-#include <boost/fusion/adapted/struct/struct_iterator.hpp>
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_ADAPT_STRUCT_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_ADAPT_STRUCT_HPP
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/empty.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+#include <boost/fusion/adapted/struct/detail/extension.hpp>
+#include <boost/fusion/adapted/struct/detail/adapt_base.hpp>
+#include <boost/fusion/adapted/struct/detail/at_impl.hpp>
 #include <boost/fusion/adapted/struct/detail/is_view_impl.hpp>
 #include <boost/fusion/adapted/struct/detail/is_sequence_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/value_at_impl.hpp>
 #include <boost/fusion/adapted/struct/detail/category_of_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/size_impl.hpp>
 #include <boost/fusion/adapted/struct/detail/begin_impl.hpp>
 #include <boost/fusion/adapted/struct/detail/end_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/size_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/at_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/value_at_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/value_of_impl.hpp>
+#include <boost/fusion/adapted/struct/detail/deref_impl.hpp>
 
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/seq/for_each_i.hpp>
-#include <boost/preprocessor/tuple/elem.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/config/no_tr1/utility.hpp>
+#define BOOST_FUSION_ADAPT_STRUCT_FILLER_0(X, Y)                                \
+    ((X, Y)) BOOST_FUSION_ADAPT_STRUCT_FILLER_1
+#define BOOST_FUSION_ADAPT_STRUCT_FILLER_1(X, Y)                                \
+    ((X, Y)) BOOST_FUSION_ADAPT_STRUCT_FILLER_0
+#define BOOST_FUSION_ADAPT_STRUCT_FILLER_0_END
+#define BOOST_FUSION_ADAPT_STRUCT_FILLER_1_END
 
-#define BOOST_FUSION_ADAPT_STRUCT(name, bseq)                                   \
-    BOOST_FUSION_ADAPT_STRUCT_I(                                                \
-        name, BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_X bseq, 0))                \
-    /***/
+#define BOOST_FUSION_ADAPT_STRUCT_C(TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE)\
+    BOOST_FUSION_ADAPT_STRUCT_C_BASE(                                           \
+        TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,BOOST_PP_EMPTY(),ATTRIBUTE,2)
 
-#define BOOST_FUSION_ADAPT_STRUCT_X(x, y) ((x, y)) BOOST_FUSION_ADAPT_STRUCT_Y
-#define BOOST_FUSION_ADAPT_STRUCT_Y(x, y) ((x, y)) BOOST_FUSION_ADAPT_STRUCT_X
-#define BOOST_FUSION_ADAPT_STRUCT_X0
-#define BOOST_FUSION_ADAPT_STRUCT_Y0
+#define BOOST_FUSION_ADAPT_TPL_STRUCT(TEMPLATE_PARAMS_SEQ,NAME_SEQ, ATTRIBUTES) \
+    BOOST_FUSION_ADAPT_STRUCT_BASE(                                             \
+        (1)TEMPLATE_PARAMS_SEQ,                                                 \
+        (1)NAME_SEQ,                                                            \
+        struct_tag,                                                             \
+        BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_FILLER_0 ATTRIBUTES,_END),       \
+        BOOST_FUSION_ADAPT_STRUCT_C)
 
-// BOOST_FUSION_ADAPT_STRUCT_I generates the overarching structure and uses
-// SEQ_FOR_EACH_I to generate the "linear" substructures.
-// Thanks to Paul Mensonides for the PP macro help
-
-#define BOOST_FUSION_ADAPT_STRUCT_I(name, seq)                                  \
-    namespace boost { namespace fusion { namespace traits                       \
-    {                                                                           \
-        template <>                                                             \
-        struct tag_of<name>                                                     \
-        {                                                                       \
-            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 <>                                                             \
-        struct struct_size<name> : mpl::int_<BOOST_PP_SEQ_SIZE(seq)> {};        \
-        BOOST_PP_SEQ_FOR_EACH_I(BOOST_FUSION_ADAPT_STRUCT_C, name, seq)         \
-    }}}                                                                         \
-    /***/
-
-#define BOOST_FUSION_ADAPT_STRUCT_C(r, name, i, xy)                             \
-    template <>                                                                 \
-    struct struct_member<name, i>                                               \
-    {                                                                           \
-        typedef BOOST_PP_TUPLE_ELEM(2, 0, xy) type;                             \
-        static type& call(name& struct_)                                        \
-        {                                                                       \
-            return struct_.BOOST_PP_TUPLE_ELEM(2, 1, xy);                       \
-        };                                                                      \
-    };                                                                          \
-    /***/
+#define BOOST_FUSION_ADAPT_STRUCT(NAME, ATTRIBUTES)                             \
+    BOOST_FUSION_ADAPT_STRUCT_BASE(                                             \
+        (0),                                                                    \
+        (0)(NAME),                                                              \
+        struct_tag,                                                             \
+        BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_FILLER_0 ATTRIBUTES,_END),       \
+        BOOST_FUSION_ADAPT_STRUCT_C)
 
 #endif

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

@@ -1,128 +1,41 @@
 /*=============================================================================
     Copyright (c) 2001-2007 Joel de Guzman
     Copyright (c) 2009-2010 Hartmut Kaiser
+    Copyright (c) 2010 Christopher Schmidt
 
     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_ADAPT_STRUCT_NAMED_SEP_29_2009_0748PM)
-#define BOOST_FUSION_ADAPT_STRUCT_NAMED_SEP_29_2009_0748PM
 
-#include <boost/fusion/support/tag_of_fwd.hpp>
-#include <boost/fusion/adapted/struct/extension.hpp>
-#include <boost/fusion/adapted/struct/struct_iterator.hpp>
-#include <boost/fusion/adapted/struct/detail/is_view_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/is_sequence_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/category_of_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/begin_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/end_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/size_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/at_impl.hpp>
-#include <boost/fusion/adapted/struct/detail/value_at_impl.hpp>
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_ADAPT_STRUCT_NAMED_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_ADAPT_STRUCT_NAMED_HPP
 
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/seq/for_each.hpp>
-#include <boost/preprocessor/seq/for_each_i.hpp>
-#include <boost/preprocessor/seq/elem.hpp>
-#include <boost/preprocessor/tuple/elem.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/config/no_tr1/utility.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/add_const.hpp>
+#include <boost/fusion/adapted/struct/adapt_struct.hpp>
+#include <boost/fusion/adapted/struct/detail/proxy_type.hpp>
+#include <boost/preprocessor/empty.hpp>
 
-#define BOOST_FUSION_ADAPT_STRUCT_NAMED(name, newname, bseq)                    \
-    BOOST_FUSION_ADAPT_STRUCT_NAMED_I(name, (boost)(fusion)(adapted), newname,  \
-        BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_NAMED_X bseq, 0))                \
-    /***/
-
-#define BOOST_FUSION_ADAPT_STRUCT_NAMED_NS(name, ns, newname, bseq)             \
-    BOOST_FUSION_ADAPT_STRUCT_NAMED_I(name, ns, newname,                        \
-        BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_NAMED_X bseq, 0))                \
-    /***/
-
-#define BOOST_FUSION_ADAPT_STRUCT_NAMED_X(x, y) ((x, y)) BOOST_FUSION_ADAPT_STRUCT_NAMED_Y
-#define BOOST_FUSION_ADAPT_STRUCT_NAMED_Y(x, y) ((x, y)) BOOST_FUSION_ADAPT_STRUCT_NAMED_X
-#define BOOST_FUSION_ADAPT_STRUCT_NAMED_X0
-#define BOOST_FUSION_ADAPT_STRUCT_NAMED_Y0
-
-// BOOST_FUSION_ADAPT_STRUCT_NAMED_I generates the overarching structure and uses
-// uses SEQ_FOR_EACH_I to generate the "linear" substructures.
-// Thanks to Paul Mensonides for the PP macro help
-
-#define BOOST_FUSION_ADAPT_STRUCT_NAMED_I(name, ns, newname, seq)               \
-    BOOST_PP_SEQ_FOR_EACH_R(1, BOOST_FUSION_ADAPT_STRUCT_NAMED_NS_B, _, ns)     \
-        struct newname                                                          \
-        {                                                                       \
-            newname(name& s) : s_(s) {}                                         \
-            name& s_;                                                           \
-        };                                                                      \
-    BOOST_PP_SEQ_FOR_EACH_R(1, BOOST_FUSION_ADAPT_STRUCT_NAMED_NS_E, _, ns)     \
+#define BOOST_FUSION_ADAPT_STRUCT_NAMED_C(                                      \
+    TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE)                                \
                                                                                 \
-    namespace boost { namespace fusion { namespace traits                       \
-    {                                                                           \
-        template <>                                                             \
-        struct tag_of<BOOST_FUSION_ADAPT_STRUCT_NAMED_NAME(ns, newname)>        \
-        {                                                                       \
-            typedef struct_tag type;                                            \
-        };                                                                      \
-    }}}                                                                         \
-                                                                                \
-    namespace boost { namespace mpl                                             \
-    {                                                                           \
-        template<typename>                                                      \
-        struct sequence_tag;                                                    \
-                                                                                \
-        template<>                                                              \
-        struct sequence_tag<BOOST_FUSION_ADAPT_STRUCT_NAMED_NAME(ns, newname)>  \
-        {                                                                       \
-            typedef fusion::fusion_sequence_tag type;                           \
-        };                                                                      \
-                                                                                \
-        template<>                                                              \
-        struct sequence_tag<BOOST_FUSION_ADAPT_STRUCT_NAMED_NAME(ns, newname) const> \
-        {                                                                       \
-            typedef fusion::fusion_sequence_tag type;                           \
-        };                                                                      \
-    }}                                                                          \
-                                                                                \
-    namespace boost { namespace fusion { namespace extension                    \
-    {                                                                           \
-        template <>                                                             \
-        struct struct_size<BOOST_FUSION_ADAPT_STRUCT_NAMED_NAME(ns, newname)>   \
-          : mpl::int_<BOOST_PP_SEQ_SIZE(seq)> {};                               \
-        template <typename T, int N> struct class_member_proxy;                 \
-        BOOST_PP_SEQ_FOR_EACH_I(BOOST_FUSION_ADAPT_STRUCT_NAMED_C,              \
-            (BOOST_FUSION_ADAPT_STRUCT_NAMED_NAME(ns, newname), name), seq)     \
-    }}}                                                                         \
-    /***/
+    BOOST_FUSION_ADAPT_STRUCT_C_BASE(                                           \
+        TEMPLATE_PARAMS_SEQ,NAME_SEQ, I, obj., ATTRIBUTE, 2)
 
-#define BOOST_FUSION_ADAPT_STRUCT_NAMED_NAME(ns, newname)                       \
-    BOOST_PP_SEQ_FOR_EACH_R(1, BOOST_FUSION_ADAPT_STRUCT_NAMED_NS_D, _, ns)     \
-    newname                                                                     \
-    /***/
+#define BOOST_FUSION_ADAPT_STRUCT_NAMED_NS(                                     \
+    WRAPPED_TYPE, NAMESPACE_SEQ, NAME, ATTRIBUTES)                              \
+                                                                                \
+    BOOST_FUSION_ADAPT_STRUCT_DEFINE_PROXY_TYPE(                                \
+        WRAPPED_TYPE,(0)NAMESPACE_SEQ,NAME)                                     \
+                                                                                \
+    BOOST_FUSION_ADAPT_STRUCT_BASE(                                             \
+        (0),                                                                    \
+        (0)(BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION(                    \
+            (0)NAMESPACE_SEQ)NAME),                                             \
+        struct_tag,                                                             \
+        BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_FILLER_0 ATTRIBUTES,_END),       \
+        BOOST_FUSION_ADAPT_STRUCT_NAMED_C)
 
-#define BOOST_FUSION_ADAPT_STRUCT_NAMED_NS_B(r, _, ns) namespace ns { 
-#define BOOST_FUSION_ADAPT_STRUCT_NAMED_NS_D(r, _, ns) ns::
-#define BOOST_FUSION_ADAPT_STRUCT_NAMED_NS_E(r, _, ns) }
-
-#define BOOST_FUSION_ADAPT_STRUCT_NAMED_C(r, names, i, xy)                      \
-    template <>                                                                 \
-    struct struct_member<BOOST_PP_TUPLE_ELEM(2, 0, names), i>                   \
-    {                                                                           \
-        typedef boost::mpl::if_<                                                \
-            boost::is_const<BOOST_PP_TUPLE_ELEM(2, 1, names)>                   \
-          , boost::add_const<BOOST_PP_TUPLE_ELEM(2, 0, xy)>::type               \
-          , BOOST_PP_TUPLE_ELEM(2, 0, xy)>::type type;                          \
-        static type& call(BOOST_PP_TUPLE_ELEM(2, 0, names)& struct_)            \
-        {                                                                       \
-            return struct_.s_.BOOST_PP_TUPLE_ELEM(2, 1, xy);                    \
-        }                                                                       \
-    };                                                                          \
-    /***/
+#define BOOST_FUSION_ADAPT_STRUCT_NAMED(WRAPPED_TYPE, NAME, ATTRIBUTES)         \
+    BOOST_FUSION_ADAPT_STRUCT_NAMED_NS(                                         \
+        WRAPPED_TYPE,(boost)(fusion)(adapted),NAME,ATTRIBUTES)
 
 #endif
-

include/boost/fusion/adapted/struct/detail/adapt_base.hpp

@@ -0,0 +1,203 @@
+/*=============================================================================
+    Copyright (c) 2001-2009 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_BASE_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_BASE_HPP
+
+#include <boost/config.hpp>
+#include <boost/fusion/support/tag_of_fwd.hpp>
+
+#include <boost/preprocessor/empty.hpp>
+#include <boost/preprocessor/stringize.hpp>
+#include <boost/preprocessor/control/if.hpp>
+#include <boost/preprocessor/seq/size.hpp>
+#include <boost/preprocessor/seq/for_each.hpp>
+#include <boost/preprocessor/seq/for_each_i.hpp>
+#include <boost/preprocessor/seq/enum.hpp>
+#include <boost/preprocessor/seq/seq.hpp>
+#include <boost/preprocessor/tuple/eat.hpp>
+#include <boost/preprocessor/tuple/elem.hpp>
+#include <boost/mpl/tag.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/add_const.hpp>
+
+#define BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME_TEMPLATE_PARAMS(SEQ)              \
+    BOOST_PP_SEQ_HEAD(SEQ)<BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TAIL(SEQ))>           \
+    BOOST_PP_EMPTY()
+
+#define BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(SEQ)                              \
+    BOOST_PP_IF(                                                                \
+        BOOST_PP_SEQ_HEAD(SEQ),                                                 \
+        BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME_TEMPLATE_PARAMS,                  \
+        BOOST_PP_SEQ_HEAD)(BOOST_PP_SEQ_TAIL(SEQ))
+
+#define BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL_C(R, _, ELEM)     \
+    (typename ELEM)
+#define BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL(SEQ)              \
+    BOOST_PP_SEQ_ENUM(                                                          \
+        BOOST_PP_SEQ_FOR_EACH(                                                  \
+            BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL_C,            \
+            _,                                                                  \
+            BOOST_PP_SEQ_TAIL(SEQ)))
+#define BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(SEQ)                   \
+    BOOST_PP_IF(                                                                \
+        BOOST_PP_SEQ_HEAD(SEQ),                                                 \
+        BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL,                  \
+        BOOST_PP_TUPLE_EAT(1))(SEQ)
+
+#ifdef BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
+#   define BOOST_FUSION_ADAPT_STRUCT_TAG_OF_SPECIALIZATION(                     \
+        MODIFIER, TEMPLATE_PARAMS_SEQ, NAME_SEQ, TAG)                           \
+                                                                                \
+    template<                                                                   \
+        BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
+    >                                                                           \
+    struct tag_of<                                                              \
+        BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) MODIFIER                \
+      , void                                                                    \
+    >                                                                           \
+    {                                                                           \
+        typedef TAG type;                                                       \
+    };
+#else
+#   define BOOST_FUSION_ADAPT_STRUCT_TAG_OF_SPECIALIZATION(                     \
+        MODIFIER, TEMPLATE_PARAMS_SEQ, NAME_SEQ, TAG)                           \
+                                                                                \
+    template<                                                                   \
+        BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
+    >                                                                           \
+    struct tag_of<BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) MODIFIER>     \
+    {                                                                           \
+        typedef TAG type;                                                       \
+    };
+#endif
+
+#define BOOST_FUSION_ADAPT_STRUCT_BASE_UNPACK_AND_CALL(R,DATA,I,ATTRIBUTE)      \
+    BOOST_PP_TUPLE_ELEM(3,0,DATA)(                                              \
+        BOOST_PP_TUPLE_ELEM(3,1,DATA),                                          \
+        BOOST_PP_TUPLE_ELEM(3,2,DATA),                                          \
+        I,                                                                      \
+        ATTRIBUTE)
+
+#define BOOST_FUSION_ADAPT_STRUCT_C_BASE(                                       \
+    TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,PREFIX,ATTRIBUTE,ATTRIBUTE_TUPEL_SIZE)       \
+                                                                                \
+    template<                                                                   \
+        BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
+    >                                                                           \
+    struct struct_member<BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ), I>    \
+    {                                                                           \
+        typedef BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 0, ATTRIBUTE) type;   \
+                                                                                \
+        template<typename Seq>                                                  \
+        struct apply                                                            \
+        {                                                                       \
+            typedef typename                                                    \
+                add_reference<                                                  \
+                    typename mpl::eval_if<                                      \
+                        is_const<Seq>                                           \
+                      , add_const<BOOST_PP_TUPLE_ELEM(                          \
+                            ATTRIBUTE_TUPEL_SIZE, 0, ATTRIBUTE)                 \
+                        >                                                       \
+                      , mpl::identity<BOOST_PP_TUPLE_ELEM(                      \
+                          ATTRIBUTE_TUPEL_SIZE, 0, ATTRIBUTE)                   \
+                        >                                                       \
+                    >::type                                                     \
+                >::type                                                         \
+            type;                                                               \
+                                                                                \
+            static type                                                         \
+            call(Seq& seq)                                                      \
+            {                                                                   \
+                return seq.PREFIX                                               \
+                    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 1, ATTRIBUTE);    \
+            }                                                                   \
+        };                                                                      \
+    };                                                                          \
+                                                                                \
+    template<                                                                   \
+        BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
+    >                                                                           \
+    struct struct_member_name<                                                  \
+        BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                         \
+      , I                                                                       \
+    >                                                                           \
+    {                                                                           \
+        typedef char const* type;                                               \
+                                                                                \
+        static type                                                             \
+        call()                                                                  \
+        {                                                                       \
+            return BOOST_PP_STRINGIZE(                                          \
+                BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,1,ATTRIBUTE));         \
+        }                                                                       \
+    };
+
+#define BOOST_FUSION_ADAPT_STRUCT_BASE(                                         \
+    TEMPLATE_PARAMS_SEQ,NAME_SEQ,TAG,ATTRIBUTES_SEQ,ATTRIBUTES_CALLBACK)        \
+                                                                                \
+namespace boost                                                                 \
+{                                                                               \
+    namespace fusion                                                            \
+    {                                                                           \
+        namespace traits                                                        \
+        {                                                                       \
+            BOOST_FUSION_ADAPT_STRUCT_TAG_OF_SPECIALIZATION(                    \
+                BOOST_PP_EMPTY(), TEMPLATE_PARAMS_SEQ, NAME_SEQ, TAG)           \
+            BOOST_FUSION_ADAPT_STRUCT_TAG_OF_SPECIALIZATION(                    \
+                const, TEMPLATE_PARAMS_SEQ, NAME_SEQ, TAG)                      \
+        }                                                                       \
+                                                                                \
+        namespace extension                                                     \
+        {                                                                       \
+            BOOST_PP_SEQ_FOR_EACH_I_R(                                          \
+                1,                                                              \
+                BOOST_FUSION_ADAPT_STRUCT_BASE_UNPACK_AND_CALL,                 \
+                (ATTRIBUTES_CALLBACK,TEMPLATE_PARAMS_SEQ,NAME_SEQ),             \
+                ATTRIBUTES_SEQ)                                                 \
+                                                                                \
+            template<                                                           \
+                BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(               \
+                    TEMPLATE_PARAMS_SEQ)                                        \
+            >                                                                   \
+            struct struct_size<BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)> \
+              : mpl::int_<BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ)>                    \
+            {};                                                                 \
+        }                                                                       \
+    }                                                                           \
+                                                                                \
+    namespace mpl                                                               \
+    {                                                                           \
+        template<typename>                                                      \
+        struct sequence_tag;                                                    \
+                                                                                \
+        template<                                                               \
+            BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(                   \
+                TEMPLATE_PARAMS_SEQ)                                            \
+        >                                                                       \
+        struct sequence_tag<BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)>    \
+        {                                                                       \
+            typedef fusion::fusion_sequence_tag type;                           \
+        };                                                                      \
+                                                                                \
+        template<                                                               \
+            BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(                   \
+                TEMPLATE_PARAMS_SEQ)                                            \
+        >                                                                       \
+        struct sequence_tag<                                                    \
+            BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) const               \
+        >                                                                       \
+        {                                                                       \
+            typedef fusion::fusion_sequence_tag type;                           \
+        };                                                                      \
+    }                                                                           \
+}
+
+#endif

include/boost/fusion/adapted/struct/detail/at_impl.hpp

@@ -1,63 +1,38 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
 
     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_AT_IMPL_24122005_1807)
-#define BOOST_FUSION_AT_IMPL_24122005_1807
 
-#include <boost/fusion/support/detail/access.hpp>
-#include <boost/mpl/assert.hpp>
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_AT_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_AT_IMPL_HPP
+
 #include <boost/mpl/int.hpp>
 
-namespace boost { namespace fusion
+namespace boost { namespace fusion { namespace extension
 {
-    struct struct_tag;
+    template<typename>
+    struct at_impl;
 
-    namespace extension
+    template <>
+    struct at_impl<struct_tag>
     {
-        template<typename T>
-        struct at_impl;
+        template <typename Seq, typename N>
+        struct apply
+          : extension::struct_member<
+                typename remove_const<Seq>::type
+              , N::value
+            >::template apply<Seq>
+        {};
+    };
 
-        template <typename Struct, int N>
-        struct struct_member;
-
-        template <typename Struct>
-        struct struct_size;
-
-        template <>
-        struct at_impl<struct_tag>
-        {
-            template <typename Sequence, typename N>
-            struct apply
-            {
-                static int const n_value = N::value;
-                BOOST_MPL_ASSERT_RELATION(
-                    n_value, <=, extension::struct_size<Sequence>::value);
-
-                typedef typename
-                    extension::struct_member<Sequence, N::value>
-                element;
-
-                typedef typename
-                    mpl::eval_if<
-                        is_const<Sequence>
-                      , detail::cref_result<element>
-                      , detail::ref_result<element>
-                    >::type
-                type;
-
-                static type
-                call(Sequence& seq)
-                {
-                    return extension::
-                        struct_member<Sequence, N::value>::call(seq);
-                }
-            };
-        };
-    }
-}}
+    template <>
+    struct at_impl<assoc_struct_tag>
+      : at_impl<struct_tag>
+    {};
+}}}
 
 #endif

include/boost/fusion/adapted/struct/detail/at_key_impl.hpp

@@ -1,54 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2007 Joel de Guzman
-    Copyright (c) 2005-2007 Dan Marsden
-
-    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_AT_KEY_IMPL_20070508_2248)
-#define BOOST_FUSION_AT_KEY_IMPL_20070508_2248
-
-#include <boost/fusion/support/detail/access.hpp>
-
-namespace boost { namespace fusion
-{
-    struct struct_tag;
-
-    namespace extension
-    {
-        template<typename T>
-        struct at_key_impl;
-
-        template <typename Struct, typename Key>
-        struct struct_assoc_member;
-
-        template <>
-        struct at_key_impl<struct_tag>
-        {
-            template <typename Sequence, typename Key>
-            struct apply
-            {
-                typedef typename
-                extension::struct_assoc_member<Sequence, Key>
-                element;
-
-                typedef typename
-                    mpl::eval_if<
-                        is_const<Sequence>
-                      , detail::cref_result<element>
-                      , detail::ref_result<element>
-                    >::type
-                type;
-
-                static type
-                call(Sequence& seq)
-                {
-                    return extension::
-                        struct_assoc_member<Sequence, Key>::call(seq);
-                }
-            };
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/struct/detail/begin_impl.hpp

@@ -1,40 +1,67 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
 
     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_BEGIN_IMPL_24122005_1752)
-#define BOOST_FUSION_BEGIN_IMPL_24122005_1752
 
-#include <boost/fusion/adapted/struct/struct_iterator.hpp>
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_BEGIN_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_BEGIN_IMPL_HPP
 
-namespace boost { namespace fusion
+#include <boost/fusion/iterator/basic_iterator.hpp>
+
+namespace boost { namespace fusion { namespace extension
 {
-    struct struct_tag;
+    template<typename>
+    struct begin_impl;
 
-    namespace extension
+    template <>
+    struct begin_impl<struct_tag>
     {
-        template<typename T>
-        struct begin_impl;
-
-        template <>
-        struct begin_impl<struct_tag>
+        template <typename Seq>
+        struct apply
         {
-            template <typename Sequence>
-            struct apply
-            {
-                typedef struct_iterator<Sequence, 0> type;
+            typedef
+                basic_iterator<
+                    struct_iterator_tag
+                  , random_access_traversal_tag
+                  , Seq
+                  , 0
+                >
+            type;
 
-                static type
-                call(Sequence& v)
-                {
-                    return type(v);
-                }
-            };
+            static type
+            call(Seq& seq)
+            {
+                return type(seq,0);
+            }
         };
-    }
-}}
+    };
+
+    template <>
+    struct begin_impl<assoc_struct_tag>
+    {
+        template <typename Seq>
+        struct apply
+        {
+            typedef
+                basic_iterator<
+                    struct_iterator_tag
+                  , assoc_struct_category
+                  , Seq
+                  , 0
+                >
+            type;
+
+            static type
+            call(Seq& seq)
+            {
+                return type(seq,0);
+            }
+        };
+    };
+}}}
 
 #endif

include/boost/fusion/adapted/struct/detail/category_of_impl.hpp

@@ -1,34 +1,41 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
 
     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_CATEGORY_OF_IMPL_24122005_1731)
-#define BOOST_FUSION_CATEGORY_OF_IMPL_24122005_1731
 
-#include <boost/config/no_tr1/utility.hpp>
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_CATEGORY_OF_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_CATEGORY_OF_IMPL_HPP
 
 namespace boost { namespace fusion
 {
-    struct struct_tag;
-    struct random_access_traversal_tag;
-
     namespace extension
     {
-        template<typename T>
+        template<typename>
         struct category_of_impl;
 
         template<>
         struct category_of_impl<struct_tag>
         {
-            template<typename T>
+            template<typename Seq>
             struct apply
             {
                 typedef random_access_traversal_tag type;
             };
         };
+
+        template<>
+        struct category_of_impl<assoc_struct_tag>
+        {
+            template<typename Seq>
+            struct apply
+            {
+                typedef assoc_struct_category type;
+            };
+        };
     }
 }}
 

include/boost/fusion/adapted/struct/detail/deref_data_impl.hpp

@@ -0,0 +1,22 @@
+/*=============================================================================
+    Copyright (c) 2009-2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_DEREF_DATA_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_DEREF_DATA_IMPL_HPP
+
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct deref_data_impl;
+
+    template <>
+    struct deref_data_impl<struct_iterator_tag>
+      : deref_impl<struct_iterator_tag>
+    {};
+}}}
+
+#endif

include/boost/fusion/adapted/struct/detail/deref_impl.hpp

@@ -0,0 +1,41 @@
+/*=============================================================================
+    Copyright (c) 2009-2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_DEREF_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_DEREF_IMPL_HPP
+
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct deref_impl;
+
+    template <>
+    struct deref_impl<struct_iterator_tag>
+    {
+        template <typename It>
+        struct apply
+        {
+           typedef typename
+               extension::struct_member<
+                   typename remove_const<typename It::seq_type>::type
+                 , It::index::value
+               >::template apply<typename It::seq_type>
+           impl;
+
+           typedef typename impl::type type;
+
+           static
+           type
+           call(It const& it)
+           {
+               return impl::call(*it.seq);
+           }
+        };
+    };
+}}}
+
+#endif

include/boost/fusion/adapted/struct/detail/end_impl.hpp

@@ -1,48 +1,67 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
 
     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_END_IMPL_24122005_1755)
-#define BOOST_FUSION_END_IMPL_24122005_1755
 
-#include <boost/fusion/adapted/struct/struct_iterator.hpp>
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_END_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_END_IMPL_HPP
 
-namespace boost { namespace fusion
+#include <boost/fusion/iterator/basic_iterator.hpp>
+
+namespace boost { namespace fusion { namespace extension
 {
-    struct struct_tag;
+    template <typename>
+    struct end_impl;
 
-    namespace extension
+    template <>
+    struct end_impl<struct_tag>
     {
-        template <typename Tag>
-        struct end_impl;
-
-        template <typename Struct>
-        struct struct_size;
-
-        template <>
-        struct end_impl<struct_tag>
+        template <typename Seq>
+        struct apply
         {
-            template <typename Sequence>
-            struct apply
-            {
-                typedef
-                    struct_iterator<
-                        Sequence
-                      , struct_size<Sequence>::value
-                    >
-                type;
+            typedef
+                basic_iterator<
+                    struct_iterator_tag
+                  , random_access_traversal_tag
+                  , Seq
+                  , struct_size<typename remove_const<Seq>::type>::value
+                >
+            type;
 
-                static type
-                call(Sequence& v)
-                {
-                    return type(v);
-                }
-            };
+            static type
+            call(Seq& seq)
+            {
+                return type(seq,0);
+            }
         };
-    }
-}}
+    };
+
+    template <>
+    struct end_impl<assoc_struct_tag>
+    {
+        template <typename Seq>
+        struct apply
+        {
+            typedef
+                basic_iterator<
+                    struct_iterator_tag
+                  , assoc_struct_category
+                  , Seq
+                  , struct_size<typename remove_const<Seq>::type>::value
+                >
+            type;
+
+            static type
+            call(Seq& seq)
+            {
+                return type(seq,0);
+            }
+        };
+    };
+}}}
 
 #endif

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

@@ -0,0 +1,44 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_EXTENSION_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_EXTENSION_HPP
+
+#include <boost/fusion/support/category_of.hpp>
+
+namespace boost { namespace fusion
+{
+    struct struct_tag;
+    struct struct_iterator_tag;
+    struct assoc_struct_tag;
+    struct fusion_sequence_tag;
+
+    struct assoc_struct_category
+      : bidirectional_traversal_tag, associative_tag
+    {};
+
+    namespace extension
+    {
+        struct no_such_member;
+
+        template<typename Seq, int N>
+        struct struct_member;
+
+        template<typename Seq, int N>
+        struct struct_member_name;
+
+        template<typename Seq, int N>
+        struct struct_assoc_key;
+
+        template<typename Seq>
+        struct struct_size;
+    }
+}}
+
+#endif

include/boost/fusion/adapted/struct/detail/has_key_impl.hpp

@@ -1,40 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2007 Joel de Guzman
-    Copyright (c) 2005-2007 Dan Marsden
-
-    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_HAS_KEY_IMPL_20070508_2231)
-#define BOOST_FUSION_HAS_KEY_IMPL_20070508_2231
-
-#include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/not.hpp>
-
-namespace boost { namespace fusion {
-
-    struct struct_tag;
-
-    namespace extension
-    {
-        struct no_such_member;
-
-        template<typename T>
-        struct has_key_impl;
-
-        template<typename Struct, typename Key>
-        struct struct_assoc_member;
-
-        template<>
-        struct has_key_impl<struct_tag>
-        {
-            template<typename Sequence, typename Key>
-            struct apply
-                : mpl::not_<is_same<no_such_member, typename struct_assoc_member<Sequence, Key>::type> >
-            {
-            };
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/struct/detail/is_sequence_impl.hpp

@@ -1,31 +1,35 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
 
     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_IS_SEQUENCE_IMPL_27122005_1651)
-#define BOOST_FUSION_IS_SEQUENCE_IMPL_27122005_1651
+
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_IS_SEQUENCE_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_IS_SEQUENCE_IMPL_HPP
 
 #include <boost/mpl/bool.hpp>
 
-namespace boost { namespace fusion
+namespace boost { namespace fusion { namespace extension
 {
-    struct struct_tag;
+    template<typename>
+    struct is_sequence_impl;
 
-    namespace extension
+    template<>
+    struct is_sequence_impl<struct_tag>
     {
-        template<typename Tag>
-        struct is_sequence_impl;
+        template<typename Seq>
+        struct apply
+          : mpl::true_
+        {};
+    };
 
-        template<>
-        struct is_sequence_impl<struct_tag>
-        {
-            template<typename Sequence>
-            struct apply : mpl::true_ {};
-        };
-    }
-}}
+    template <>
+    struct is_sequence_impl<assoc_struct_tag>
+      : is_sequence_impl<struct_tag>
+    {};
+}}}
 
 #endif

include/boost/fusion/adapted/struct/detail/is_view_impl.hpp

@@ -1,32 +1,35 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
 
     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_IS_VIEW_IMPL_27042006_2219)
-#define BOOST_FUSION_IS_VIEW_IMPL_27042006_2219
+
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_IS_VIEW_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_IS_VIEW_IMPL_HPP
 
 #include <boost/mpl/bool.hpp>
 
-namespace boost { namespace fusion
+namespace boost { namespace fusion { namespace extension
 {
-    struct struct_tag;
+    template<typename>
+    struct is_view_impl;
 
-    namespace extension
+    template<>
+    struct is_view_impl<struct_tag>
     {
-        template<typename Tag>
-        struct is_view_impl;
+        template<typename Seq>
+        struct apply
+          : mpl::false_
+        {};
+    };
 
-        template<>
-        struct is_view_impl<struct_tag>
-        {
-            template<typename T>
-            struct apply : mpl::false_
-            {};
-        };
-    }
-}}
+    template <>
+    struct is_view_impl<assoc_struct_tag>
+      : is_view_impl<struct_tag>
+    {};
+}}}
 
 #endif

include/boost/fusion/adapted/struct/detail/key_of_impl.hpp

@@ -0,0 +1,29 @@
+/*=============================================================================
+    Copyright (c) 2009-2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_KEY_OF_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_KEY_OF_IMPL_HPP
+
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct key_of_impl;
+
+    template <>
+    struct key_of_impl<struct_iterator_tag>
+    {
+        template <typename It>
+        struct apply
+          : extension::struct_assoc_key<
+                typename remove_const<typename It::seq_type>::type
+              , It::index::value
+            >
+        {};
+    };
+}}}
+
+#endif

include/boost/fusion/adapted/struct/detail/proxy_type.hpp

@@ -0,0 +1,61 @@
+/*=============================================================================
+    Copyright (c) 2009-2010 Hartmut Kaiser
+    Copyright (c) 2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_PROXY_TYPE_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_PROXY_TYPE_HPP
+
+#include <boost/preprocessor/dec.hpp>
+#include <boost/preprocessor/control/if.hpp>
+#include <boost/preprocessor/seq/seq.hpp>
+#include <boost/preprocessor/seq/for_each.hpp>
+#include <boost/preprocessor/seq/size.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+
+#define BOOST_FUSION_ADAPT_STRUCT_PROXY_DUMMY4(A,B,C,D)
+#define BOOST_FUSION_ADAPT_STRUCT_PROXY_TYPE_NS_BEGIN(R,DATA,ELEM)              \
+    namespace ELEM {
+#define BOOST_FUSION_ADAPT_STRUCT_PROXY_TYPE_NS_END(Z,I,DATA) }
+#define BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION_I(Z,I,ELEM) ELEM::
+
+#define BOOST_FUSION_ADAPT_STRUCT_DEFINE_PROXY_TYPE(                            \
+    WRAPPED_TYPE,NAMESPACE_SEQ,NAME)                                            \
+                                                                                \
+    BOOST_PP_IF(                                                                \
+        BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(NAMESPACE_SEQ)),                         \
+        BOOST_PP_SEQ_FOR_EACH_R,                                                \
+        BOOST_FUSION_ADAPT_STRUCT_PROXY_DUMMY4)(                                \
+            1,                                                                  \
+            BOOST_FUSION_ADAPT_STRUCT_PROXY_TYPE_NS_BEGIN,                      \
+            _,                                                                  \
+            BOOST_PP_SEQ_TAIL(NAMESPACE_SEQ))                                   \
+                                                                                \
+    struct NAME                                                                 \
+    {                                                                           \
+        NAME(WRAPPED_TYPE& obj)                                                 \
+          : obj(obj)                                                            \
+        {}                                                                      \
+                                                                                \
+        WRAPPED_TYPE& obj;                                                      \
+    };                                                                          \
+                                                                                \
+    BOOST_PP_REPEAT_1(                                                          \
+        BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(NAMESPACE_SEQ)),                         \
+        BOOST_FUSION_ADAPT_STRUCT_PROXY_TYPE_NS_END,                            \
+        _)
+
+#define BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION(NAMESPACE_SEQ)          \
+    BOOST_PP_IF(                                                                \
+        BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(NAMESPACE_SEQ)),                         \
+        BOOST_PP_SEQ_FOR_EACH_R,                                                \
+        BOOST_FUSION_ADAPT_STRUCT_PROXY_DUMMY4)(                                \
+            1,                                                                  \
+            BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION_I,                  \
+            _,                                                                  \
+            BOOST_PP_SEQ_TAIL(NAMESPACE_SEQ))
+
+#endif

include/boost/fusion/adapted/struct/detail/size_impl.hpp

@@ -1,37 +1,33 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
 
     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_SIZE_IMPL_24122005_1759)
-#define BOOST_FUSION_SIZE_IMPL_24122005_1759
 
-#include <boost/mpl/int.hpp>
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_SIZE_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_SIZE_IMPL_HPP
 
-namespace boost { namespace fusion
+namespace boost { namespace fusion { namespace extension
 {
-    namespace extension
+    template<typename>
+    struct size_impl;
+
+    template <>
+    struct size_impl<struct_tag>
     {
-        template <typename Struct>
-        struct struct_size;
-    }
+        template <typename Seq>
+        struct apply
+          : struct_size<typename remove_const<Seq>::type>
+        {};
+    };
 
-    struct struct_tag;
-
-    namespace extension
-    {
-        template<typename T>
-        struct size_impl;
-
-        template <>
-        struct size_impl<struct_tag>
-        {
-            template <typename Sequence>
-            struct apply : extension::struct_size<Sequence> {};
-        };
-    }
-}}
+    template <>
+    struct size_impl<assoc_struct_tag>
+      : size_impl<struct_tag>
+    {};
+}}}
 
 #endif

include/boost/fusion/adapted/struct/detail/value_at_impl.hpp

@@ -1,47 +1,33 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
 
     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_VALUE_AT_IMPL_24122005_1917)
-#define BOOST_FUSION_VALUE_AT_IMPL_24122005_1917
 
-#include <boost/mpl/if.hpp>
-#include <boost/static_assert.hpp>
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_VALUE_AT_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_VALUE_AT_IMPL_HPP
 
-namespace boost { namespace fusion
+namespace boost { namespace fusion { namespace extension
 {
-    struct struct_tag;
+    template<typename>
+    struct value_at_impl;
 
-    namespace extension
+    template <>
+    struct value_at_impl<struct_tag>
     {
-        template<typename T>
-        struct value_at_impl;
+        template <typename Seq, typename N>
+        struct apply
+          : struct_member<typename remove_const<Seq>::type, N::value>
+        {};
+    };
 
-        template <typename Struct, int N>
-        struct struct_member;
-
-        template <typename Struct>
-        struct struct_size;
-
-        template <>
-        struct value_at_impl<struct_tag>
-        {
-            template <typename Sequence, typename N>
-            struct apply
-            {
-                static int const n_value = N::value;
-                BOOST_MPL_ASSERT_RELATION(
-                    n_value, <=, extension::struct_size<Sequence>::value);
-
-                typedef typename
-                    extension::struct_member<Sequence, N::value>::type
-                type;
-            };
-        };
-    }
-}}
+    template <>
+    struct value_at_impl<assoc_struct_tag>
+      : value_at_impl<struct_tag>
+    {};
+}}}
 
 #endif

include/boost/fusion/adapted/struct/detail/value_at_key_impl.hpp

@@ -1,39 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2007 Joel de Guzman
-    Copyright (c) 2005-2007 Dan Marsden
-
-    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_VALUE_AT_KEY_IMPL_20070508_2300)
-#define BOOST_FUSION_VALUE_AT_KEY_IMPL_20070508_2300
-
-#include <boost/mpl/if.hpp>
-
-namespace boost { namespace fusion
-{
-    struct struct_tag;
-
-    namespace extension
-    {
-        template<typename T>
-        struct value_at_key_impl;
-
-        template <typename Struct, typename Key>
-        struct struct_assoc_member;
-
-        template <>
-        struct value_at_key_impl<struct_tag>
-        {
-            template <typename Sequence, typename Key>
-            struct apply
-            {
-                typedef typename
-                    extension::struct_assoc_member<Sequence, Key>::type
-                type;
-            };
-        };
-    }
-}}
-
-#endif

include/boost/fusion/adapted/struct/detail/value_of_data_impl.hpp

@@ -0,0 +1,22 @@
+/*=============================================================================
+    Copyright (c) 2009-2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_VALUE_OF_DATA_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_VALUE_OF_DATA_IMPL_HPP
+
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct value_of_data_impl;
+
+    template <>
+    struct value_of_data_impl<struct_iterator_tag>
+      : value_of_impl<struct_iterator_tag>
+    {};
+}}}
+
+#endif

include/boost/fusion/adapted/struct/detail/value_of_impl.hpp

@@ -0,0 +1,29 @@
+/*=============================================================================
+    Copyright (c) 2009-2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_VALUE_OF_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_VALUE_OF_IMPL_HPP
+
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct value_of_impl;
+
+    template <>
+    struct value_of_impl<struct_iterator_tag>
+    {
+        template <typename It>
+        struct apply
+          : extension::struct_member<
+                typename remove_const<typename It::seq_type>::type
+              , It::index::value
+            >
+        {};
+    };
+}}}
+
+#endif

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

@@ -1,73 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2007 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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(FUSION_STRUCT_EXTENSION_APRIL_2_2007_1008AM)
-#define FUSION_STRUCT_EXTENSION_APRIL_2_2007_1008AM
-
-#include <boost/type_traits/add_const.hpp>
-
-namespace boost { namespace fusion
-{
-    struct fusion_sequence_tag;
-
-    namespace extension
-    {
-        template <typename Struct, int N>
-        struct struct_member;
-
-        template <typename Struct>
-        struct struct_size;
-
-        template <typename Struct, int N>
-        struct struct_member<Struct const, N>
-        {
-            typedef typename
-                add_const<typename struct_member<Struct, N>::type>::type
-            type;
-
-            static type&
-            call(Struct const& struct_)
-            {
-                return struct_member<Struct, N>::call(
-                    const_cast<Struct&>(struct_));
-            }
-        };
-
-        template <typename Struct>
-        struct struct_size<Struct const>
-            : struct_size<Struct>
-        {};
-
-        struct no_such_member;
-
-        template<typename Struct, typename Key>
-        struct struct_assoc_member
-        {
-            typedef no_such_member type;
-        };
-
-        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
-
-

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

@@ -1,107 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2007 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    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(FUSION_STRUCT_ITERATOR_APRIL_2_2007_1008AM)
-#define FUSION_STRUCT_ITERATOR_APRIL_2_2007_1008AM
-
-#include <boost/fusion/iterator/iterator_facade.hpp>
-#include <boost/fusion/adapted/struct/extension.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/minus.hpp>
-#include <boost/config/no_tr1/utility.hpp>
-
-namespace boost { namespace fusion
-{
-    struct random_access_traversal_tag;
-
-    template <typename Struct, int N_>
-    struct struct_iterator
-        : iterator_facade<struct_iterator<Struct, N_>, random_access_traversal_tag>
-    {
-        BOOST_MPL_ASSERT_RELATION(N_, >=, 0);
-        BOOST_MPL_ASSERT_RELATION(N_, <=, extension::struct_size<Struct>::value);
-
-        typedef mpl::int_<N_> index;
-        typedef Struct struct_type;
-
-        struct_iterator(Struct& struct_)
-            : struct_(struct_) {}
-        Struct& struct_;
-
-        template <typename Iterator>
-        struct value_of
-            : extension::struct_member<Struct, N_>
-        {
-        };
-
-        template <typename Iterator>
-        struct deref
-        {
-            typedef typename
-                add_reference<
-                    typename extension::struct_member<Struct, N_>::type
-                >::type
-            type;
-
-            static type
-            call(Iterator const& iter)
-            {
-                return extension::struct_member<Struct, N_>::
-                    call(iter.struct_);
-            }
-        };
-
-        template <typename Iterator, typename N>
-        struct advance
-        {
-            typedef typename Iterator::index index;
-            typedef typename Iterator::struct_type struct_type;
-            typedef struct_iterator<struct_type, index::value + N::value> type;
-
-            static type
-            call(Iterator const& iter)
-            {
-                return type(iter.struct_);
-            }
-        };
-
-        template <typename Iterator>
-        struct next : advance<Iterator, mpl::int_<1> > {};
-
-        template <typename Iterator>
-        struct prior : advance<Iterator, mpl::int_<-1> > {};
-
-        template <typename I1, typename I2>
-        struct distance : mpl::minus<typename I2::index, typename I1::index>
-        {
-            typedef typename
-                mpl::minus<
-                    typename I2::index, typename I1::index
-                >::type
-            type;
-
-            static type
-            call(I1 const&, I2 const&)
-            {
-                return type();
-            }
-        };
-
-    private:
-        // silence MSVC warning C4512: assignment operator could not be generated
-        struct_iterator& operator= (struct_iterator const&);
-    };
-}}
-
-#endif
-
-

include/boost/fusion/include/adapt_assoc_class.hpp

@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_INCLUDE_ADAPT_ASSOC_CLASS_HPP
+#define BOOST_FUSION_INCLUDE_ADAPT_ASSOC_CLASS_HPP
+
+#include <boost/fusion/adapted/class/adapt_assoc_class.hpp>
+
+#endif

include/boost/fusion/include/adapt_assoc_class_named.hpp

@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_INCLUDE_ADAPT_ASSOC_CLASS_NAMED_HPP
+#define BOOST_FUSION_INCLUDE_ADAPT_ASSOC_CLASS_NAMED_HPP
+
+#include <boost/fusion/adapted/class/adapt_assoc_class_named.hpp>
+
+#endif

include/boost/fusion/include/adapt_assoc_struct.hpp

@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_INCLUDE_ADAPT_ASSOC_STRUCT_HPP
+#define BOOST_FUSION_INCLUDE_ADAPT_ASSOC_STRUCT_HPP
+
+#include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp>
+
+#endif

include/boost/fusion/include/adapt_assoc_struct_named.hpp

@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_INCLUDE_ADAPT_ASSOC_STRUCT_NAMED_HPP
+#define BOOST_FUSION_INCLUDE_ADAPT_ASSOC_STRUCT_NAMED_HPP
+
+#include <boost/fusion/adapted/struct/adapt_assoc_struct_named.hpp>
+
+#endif

include/boost/fusion/include/adapt_class.hpp

@@ -1,11 +1,12 @@
 /*=============================================================================
-    Copyright (c) 2001-2009 Joel de Guzman
+    Copyright (c) 2001-2007 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)
 ==============================================================================*/
-#if !defined(FUSION_INCLUDE_ADAPT_CLASS)
-#define FUSION_INCLUDE_ADAPT_CLASS
+
+#ifndef BOOST_FUSION_INCLUDE_ADAPT_CLASS_HPP
+#define BOOST_FUSION_INCLUDE_ADAPT_CLASS_HPP
 
 #include <boost/fusion/adapted/class/adapt_class.hpp>
 

include/boost/fusion/include/adapt_class_named.hpp

@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_INCLUDE_ADAPT_CLASS_NAMED_HPP
+#define BOOST_FUSION_INCLUDE_ADAPT_CLASS_NAMED_HPP
+
+#include <boost/fusion/adapted/class/adapt_class_named.hpp>
+
+#endif

include/boost/fusion/include/adapt_struct.hpp

@@ -4,8 +4,9 @@
     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(FUSION_INCLUDE_ADAPT_STRUCT)
-#define FUSION_INCLUDE_ADAPT_STRUCT
+
+#ifndef BOOST_FUSION_INCLUDE_ADAPT_STRUCT_HPP
+#define BOOST_FUSION_INCLUDE_ADAPT_STRUCT_HPP
 
 #include <boost/fusion/adapted/struct/adapt_struct.hpp>
 

include/boost/fusion/include/adapt_struct_named.hpp

@@ -1,11 +1,12 @@
 /*=============================================================================
-    Copyright (c) 2001-2007 Joel de Guzman
+    Copyright (c) 2010 Christopher Schmidt
 
     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(FUSION_INCLUDE_ADAPT_STRUCT_NAMED)
-#define FUSION_INCLUDE_ADAPT_STRUCT_NAMED
+
+#ifndef BOOST_FUSION_INCLUDE_ADAPT_STRUCT_NAMED_HPP
+#define BOOST_FUSION_INCLUDE_ADAPT_STRUCT_NAMED_HPP
 
 #include <boost/fusion/adapted/struct/adapt_struct_named.hpp>
 

include/boost/fusion/sequence/comparison/detail/greater.hpp

@@ -32,9 +32,8 @@ namespace boost { namespace fusion { namespace detail
         static bool
         call(I1 const& a, I2 const& b, mpl::false_)
         {
-            return *a > *b
-                || !(*b > *a)
-                && call(fusion::next(a), fusion::next(b));
+            return *a > *b ||
+                (!(*b > *a) && call(fusion::next(a), fusion::next(b)));
         }
 
         template <typename I1, typename I2>

include/boost/fusion/sequence/comparison/detail/less.hpp

@@ -32,9 +32,8 @@ namespace boost { namespace fusion { namespace detail
         static bool
         call(I1 const& a, I2 const& b, mpl::false_)
         {
-            return *a < *b
-                || !(*b < *a)
-                && call(fusion::next(a), fusion::next(b));
+            return *a < *b ||
+                (!(*b < *a) && call(fusion::next(a), fusion::next(b)));
         }
 
         template <typename I1, typename I2>

include/boost/fusion/support/is_sequence.hpp

@@ -56,8 +56,9 @@ namespace boost { namespace fusion
     {
         template <typename T>
         struct is_sequence
-            : extension::is_sequence_impl<typename detail::tag_of<T>::type>::
-                template apply<T>
+          : extension::is_sequence_impl<
+                typename fusion::detail::tag_of<T>::type
+            >::template apply<T>
         {};
     }
 }}

test/Jamfile

@@ -108,12 +108,19 @@ import testing ;
     [ run sequence/zip_view_ignore.cpp : : : : ]
     [ run sequence/repetitive_view.cpp : : : : ]
     [ run sequence/deduce_sequence.cpp : : : : ]
-    [ run sequence/adapt_struct.cpp : : : : ]
+    [ run sequence/adapt_assoc_class_named.cpp : : : : ]
+    [ run sequence/adapt_assoc_class.cpp : : : : ]
+    [ run sequence/adapt_assoc_struct_named.cpp : : : : ]
     [ run sequence/adapt_assoc_struct.cpp : : : : ]
-    [ run sequence/adapt_struct_named.cpp : : : : ]
-    [ run sequence/adapt_class.cpp : : : : ]
+    [ run sequence/adapt_assoc_tpl_class.cpp : : : : ]
+    [ run sequence/adapt_assoc_tpl_struct.cpp : : : : ]
     [ run sequence/adapt_class_named.cpp : : : : ]
-
+    [ run sequence/adapt_class.cpp : : : : ]
+    [ run sequence/adapt_struct_named.cpp : : : : ]
+    [ run sequence/adapt_struct.cpp : : : : ]
+    [ run sequence/adapt_tpl_class.cpp : : : : ]
+    [ run sequence/adapt_tpl_struct.cpp : : : : ]
+    
     [ run functional/fused.cpp : : : : ]
     [ run functional/fused_function_object.cpp : : : : ]
     [ run functional/fused_procedure.cpp : : : : ]

test/sequence/adapt_assoc_class.cpp

@@ -0,0 +1,136 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    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/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/support.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/adapted/class/adapt_assoc_class.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    struct x_member;
+    struct y_member;
+    struct z_member;
+
+    class point
+    {
+    public:
+    
+        point() : x(0), y(0) {}
+        point(int x, int y) : x(x), y(y) {}
+            
+        int get_x() const { return x; }
+        int get_y() const { return y; }
+        void set_x(int x_) { x = x_; }
+        void set_y(int y_) { y = y_; }
+        
+    private:
+        
+        int x;
+        int y;
+    };
+}
+
+BOOST_FUSION_ADAPT_ASSOC_CLASS(
+    ns::point,
+    (int, int, obj.get_x(), obj.set_x(val), ns::x_member)
+    (int, int, obj.get_y(), obj.set_y(val), ns::y_member)
+)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace std;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<ns::point>));
+        ns::point p(123, 456);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(result_of::size<ns::point>::value == 2);
+        BOOST_STATIC_ASSERT(!result_of::empty<ns::point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        boost::fusion::vector<int, float> v1(4, 2);
+        ns::point v2(5, 3);
+        boost::fusion::vector<long, double> v3(5, 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from ns::point to vector
+        ns::point p(5, 3);
+        boost::fusion::vector<int, short> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from ns::point to list
+        ns::point p(5, 3);
+        boost::fusion::list<int, short> l(p);
+        l = p;
+    }
+
+    {
+        BOOST_MPL_ASSERT((boost::mpl::is_sequence<ns::point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            boost::fusion::result_of::value_at_c<ns::point,0>::type
+          , boost::mpl::front<ns::point>::type>));
+    }
+
+    {
+        // assoc stuff
+        BOOST_MPL_ASSERT((result_of::has_key<ns::point, ns::x_member>));
+        BOOST_MPL_ASSERT((result_of::has_key<ns::point, ns::y_member>));
+        BOOST_MPL_ASSERT((boost::mpl::not_<result_of::has_key<ns::point, ns::z_member> >));
+
+        BOOST_MPL_ASSERT((boost::is_same<result_of::value_at_key<ns::point, ns::x_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<result_of::value_at_key<ns::point, ns::y_member>::type, int>));
+
+        ns::point p(5, 3);
+
+        BOOST_TEST(at_key<ns::x_member>(p) == 5);
+        BOOST_TEST(at_key<ns::y_member>(p) == 3);
+    }
+
+    return boost::report_errors();
+}
+

test/sequence/adapt_assoc_class_named.cpp

@@ -0,0 +1,142 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    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/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/support.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/adapted/class/adapt_assoc_class_named.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    struct x_member;
+    struct y_member;
+    struct z_member;
+
+    class point
+    {
+    public:
+    
+        point() : x(0), y(0) {}
+        point(int x, int y) : x(x), y(y) {}
+            
+        int get_x() const { return x; }
+        int get_y() const { return y; }
+        void set_x(int x_) { x = x_; }
+        void set_y(int y_) { y = y_; }
+        
+    private:
+        
+        int x;
+        int y;
+    };
+}
+
+BOOST_FUSION_ADAPT_ASSOC_CLASS_NAMED(
+    ns::point,
+    point,
+    (int, int, obj.obj.get_x(), obj.obj.set_x(val), ns::x_member)
+    (int, int, obj.obj.get_y(), obj.obj.set_y(val), ns::y_member)
+)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace std;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<adapted::point>));
+        ns::point basep(123, 456);
+        adapted::point p(basep);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(result_of::size<adapted::point>::value == 2);
+        BOOST_STATIC_ASSERT(!result_of::empty<adapted::point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        boost::fusion::vector<int, float> v1(4, 2);
+        ns::point basev2(5, 3);
+        adapted::point v2(basev2);
+        boost::fusion::vector<long, double> v3(5, 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from adapted::point to vector
+        ns::point basep(5, 3);
+        adapted::point p(basep);
+        boost::fusion::vector<int, short> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from adated::point to list
+        ns::point basep(5, 3);
+        adapted::point p(basep);
+        boost::fusion::list<int, short> l(p);
+        l = p;
+    }
+
+    {
+        BOOST_MPL_ASSERT((boost::mpl::is_sequence<adapted::point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            boost::fusion::result_of::value_at_c<adapted::point,0>::type
+          , boost::mpl::front<adapted::point>::type>));
+    }
+
+    {
+        // assoc stuff
+        BOOST_MPL_ASSERT((result_of::has_key<adapted::point, ns::x_member>));
+        BOOST_MPL_ASSERT((result_of::has_key<adapted::point, ns::y_member>));
+        BOOST_MPL_ASSERT((boost::mpl::not_<result_of::has_key<adapted::point, ns::z_member> >));
+
+        BOOST_MPL_ASSERT((boost::is_same<result_of::value_at_key<adapted::point, ns::x_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<result_of::value_at_key<adapted::point, ns::y_member>::type, int>));
+
+        ns::point basep(5, 3);
+        adapted::point p(basep);
+
+        BOOST_TEST(at_key<ns::x_member>(p) == 5);
+        BOOST_TEST(at_key<ns::y_member>(p) == 3);
+    }
+
+    return boost::report_errors();
+}
+

test/sequence/adapt_assoc_struct_named.cpp

@@ -0,0 +1,121 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    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/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/support.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/adapted/struct/adapt_assoc_struct_named.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    struct x_member;
+    struct y_member;
+    struct z_member;
+
+    struct point
+    {
+        int x;
+        int y;
+    };
+}
+
+BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(
+    ns::point,
+    point,
+    (int, x, ns::x_member)
+    (int, y, ns::y_member)
+)
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<adapted::point>));
+        ns::point basep = {123, 456};
+        adapted::point p(basep);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(result_of::size<adapted::point>::value == 2);
+        BOOST_STATIC_ASSERT(!result_of::empty<adapted::point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        vector<int, float> v1(4, 2);
+        ns::point basev2 = {5, 3};
+        adapted::point v2(basev2);
+
+        vector<long, double> v3(5, 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from adapted::point to vector
+        ns::point basep = {5, 3};
+        adapted::point p(basep);
+        vector<int, short> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from adapted::point to list
+        ns::point basep = {5, 3};
+        adapted::point p(basep);
+        list<int, short> l(p);
+        l = p;
+    }
+
+    {
+        // assoc stuff
+        BOOST_MPL_ASSERT((result_of::has_key<adapted::point, ns::x_member>));
+        BOOST_MPL_ASSERT((result_of::has_key<adapted::point, ns::y_member>));
+        BOOST_MPL_ASSERT((boost::mpl::not_<result_of::has_key<adapted::point, ns::z_member> >));
+
+        BOOST_MPL_ASSERT((boost::is_same<result_of::value_at_key<adapted::point, ns::x_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<result_of::value_at_key<adapted::point, ns::y_member>::type, int>));
+
+        ns::point basep = {5, 3};
+        adapted::point p(basep);
+        
+        BOOST_TEST(at_key<ns::x_member>(p) == 5);
+        BOOST_TEST(at_key<ns::y_member>(p) == 3);
+    }
+
+    return boost::report_errors();
+}
+

test/sequence/adapt_assoc_tpl_class.cpp

@@ -0,0 +1,140 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    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/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/support.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/adapted/class/adapt_assoc_class.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    struct x_member;
+    struct y_member;
+    struct z_member;
+
+    template<typename X, typename Y>
+    class point
+    {
+    public:
+    
+        point() : x(0), y(0) {}
+        point(X x, Y y) : x(x), y(y) {}
+            
+        X get_x() const { return x; }
+        Y get_y() const { return y; }
+        void set_x(X x_) { x = x_; }
+        void set_y(Y y_) { y = y_; }
+        
+    private:
+        
+        X x;
+        Y y;
+    };
+}
+
+BOOST_FUSION_ADAPT_ASSOC_TPL_CLASS(
+    (X)(Y),
+    (ns::point)(X)(Y),
+    (X, X, obj.get_x(), obj.set_x(val), ns::x_member)
+    (Y, Y, obj.get_y(), obj.set_y(val), ns::y_member)
+)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace std;
+
+    typedef ns::point<int,int> point;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
+        point p(123, 456);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(result_of::size<point>::value == 2);
+        BOOST_STATIC_ASSERT(!result_of::empty<point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        boost::fusion::vector<int, float> v1(4, 2);
+        point v2(5, 3);
+        boost::fusion::vector<long, double> v3(5, 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from point to vector
+        point p(5, 3);
+        boost::fusion::vector<int, short> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from point to list
+        point p(5, 3);
+        boost::fusion::list<int, short> l(p);
+        l = p;
+    }
+
+    {
+        BOOST_MPL_ASSERT((boost::mpl::is_sequence<point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            boost::fusion::result_of::value_at_c<point,0>::type
+          , boost::mpl::front<point>::type>));
+    }
+
+    {
+        // assoc stuff
+        BOOST_MPL_ASSERT((result_of::has_key<point, ns::x_member>));
+        BOOST_MPL_ASSERT((result_of::has_key<point, ns::y_member>));
+        BOOST_MPL_ASSERT((boost::mpl::not_<result_of::has_key<point, ns::z_member> >));
+
+        BOOST_MPL_ASSERT((boost::is_same<result_of::value_at_key<point, ns::x_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<result_of::value_at_key<point, ns::y_member>::type, int>));
+
+        point p(5, 3);
+
+        BOOST_TEST(at_key<ns::x_member>(p) == 5);
+        BOOST_TEST(at_key<ns::y_member>(p) == 3);
+    }
+
+    return boost::report_errors();
+}
+

test/sequence/adapt_assoc_tpl_struct.cpp

@@ -0,0 +1,133 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#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/has_key.hpp>
+#include <boost/fusion/sequence/intrinsic/at_key.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at_key.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#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/support/is_view.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    struct x_member;
+    struct y_member;
+    struct z_member;
+
+    template<typename X, typename Y>
+    struct point
+    {
+        X x;
+        Y y;
+    };
+}
+
+BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT(
+    (X)(Y),
+    (ns::point)(X)(Y),
+    (int, x, ns::x_member)
+    (int, y, ns::y_member)
+)
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    typedef ns::point<int,int> point;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
+        point p = {123, 456};
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(result_of::size<point>::value == 2);
+        BOOST_STATIC_ASSERT(!result_of::empty<point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        vector<int, float> v1(4, 2);
+        point v2 = {5, 3};
+        vector<long, double> v3(5, 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from point to vector
+        point p = {5, 3};
+        vector<int, short> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from point to list
+        point p = {5, 3};
+        list<int, short> l(p);
+        l = p;
+    }
+
+    {
+        // assoc stuff
+        BOOST_MPL_ASSERT((result_of::has_key<point, ns::x_member>));
+        BOOST_MPL_ASSERT((result_of::has_key<point, ns::y_member>));
+        BOOST_MPL_ASSERT((boost::mpl::not_<result_of::has_key<point, ns::z_member> >));
+
+        BOOST_MPL_ASSERT((boost::is_same<result_of::value_at_key<point, ns::x_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<result_of::value_at_key<point, ns::y_member>::type, int>));
+
+        point p = {5, 3};
+        
+        BOOST_TEST(at_key<ns::x_member>(p) == 5);
+        BOOST_TEST(at_key<ns::y_member>(p) == 3);
+    }
+
+    return boost::report_errors();
+}
+

test/sequence/adapt_tpl_class.cpp

@@ -0,0 +1,133 @@
+/*=============================================================================
+    Copyright (c) 2001-2009 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)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/class/adapt_class.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#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>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#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/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    template<typename X, typename Y>
+    class point
+    {
+    public:
+    
+        point() : x(0), y(0) {}
+        point(X x, Y y) : x(x), y(y) {}
+            
+        X get_x() const { return x; }
+        Y get_y() const { return y; }
+        void set_x(X x_) { x = x_; }
+        void set_y(Y y_) { y = y_; }
+        
+    private:
+        
+        X x;
+        Y y;
+    };
+}
+
+BOOST_FUSION_ADAPT_TPL_CLASS(
+    (X)(Y),
+    (ns::point)(X)(Y),
+    (X, X, obj.get_x(), obj.set_x(val))
+    (Y, Y, obj.get_y(), obj.set_y(val))
+)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace std;
+
+    typedef ns::point<int, int> point;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
+        point p(123, 456);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(result_of::size<point>::value == 2);
+        BOOST_STATIC_ASSERT(!result_of::empty<point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        boost::fusion::vector<int, float> v1(4, 2);
+        point v2(5, 3);
+        boost::fusion::vector<long, double> v3(5, 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from point to vector
+        point p(5, 3);
+        boost::fusion::vector<int, short> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from point to list
+        point p(5, 3);
+        boost::fusion::list<int, short> l(p);
+        l = p;
+    }
+
+    {
+        BOOST_MPL_ASSERT((boost::mpl::is_sequence<point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            boost::fusion::result_of::value_at_c<point,0>::type
+          , boost::mpl::front<point>::type>));
+    }
+
+    return boost::report_errors();
+}
+

test/sequence/adapt_tpl_struct.cpp

@@ -0,0 +1,122 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 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)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/adapt_struct.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#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/io/out.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#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/support/is_view.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    template<typename X, typename Y>
+    struct point
+    {
+        X x;
+        Y y;
+    };
+}
+
+BOOST_FUSION_ADAPT_TPL_STRUCT(
+    (X)(Y),
+    (ns::point)(X)(Y),
+    (X, x)
+    (Y, y)
+)
+
+template<typename M>
+struct s { M m; };
+BOOST_FUSION_ADAPT_TPL_STRUCT((M), (s)(M), (M, m))
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    typedef ns::point<int, int> point;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
+        point p = {123, 456};
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(result_of::size<point>::value == 2);
+        BOOST_STATIC_ASSERT(!result_of::empty<point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        vector<int, float> v1(4, 2);
+        point v2 = {5, 3};
+        vector<long, double> v3(5, 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from point to vector
+        point p = {5, 3};
+        vector<int, short> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from point to list
+        point p = {5, 3};
+        list<int, short> l(p);
+        l = p;
+    }
+
+    { // begin/end
+        using namespace boost::fusion;
+
+        typedef result_of::begin<s<int> >::type b;
+        typedef result_of::end<s<int> >::type e;
+        // this fails
+        BOOST_MPL_ASSERT((boost::is_same<result_of::next<b>::type, e>));
+    }
+
+    return boost::report_errors();
+}
+