feedc0de/boost_fusion
1
0
Fork 0
forked from boostorg/fusion
Code Pull Requests Activity

adapt template classes/structs

Browse Source 
[SVN r59846]
This commit is contained in:
Christopher Schmidt
2010-02-22 22:55:54 +00:00
parent bb88841f47
commit f84bc30bd3
79 changed files with 2489 additions and 2293 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
include/boost/fusion/adapted/class.hpp
View File

@ -1,29 +1,18 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2005-2006 Dan Marsden
Copyright (c) 2010 Christopher Schmidt
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_CLASS_HPP
#include <boost/fusion/adapted/class/adapt_class.hpp> #define BOOST_FUSION_ADAPTED_CLASS_HPP
#include <boost/fusion/adapted/class/adapt_class_named.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/adapt_assoc_class.hpp>
#include <boost/fusion/adapted/class/class_iterator.hpp> #include <boost/fusion/adapted/class/adapt_class_named.hpp>
#include <boost/fusion/adapted/class/adapt_class.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>
#endif #endif

144
include/boost/fusion/adapted/class/adapt_assoc_class.hpp
View File

@ -1,113 +1,69 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2009 Joel de Guzman Copyright (c) 2010 Christopher Schmidt
Copyright (c) 2007 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_CLASS_ADAPT_ASSOC_CLASS_HPP
#include <boost/fusion/adapted/class/extension.hpp> #define BOOST_FUSION_ADAPTED_CLASS_ADAPT_ASSOC_CLASS_HPP
#include <boost/fusion/adapted/class/class_iterator.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/empty.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/fusion/adapted/class/detail/extension.hpp>
#include <boost/fusion/adapted/class/detail/adapt_base.hpp>
#include <boost/fusion/adapted/class/detail/at_impl.hpp>
#include <boost/fusion/adapted/class/detail/is_view_impl.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/is_sequence_impl.hpp>
#include <boost/fusion/adapted/class/detail/value_at_impl.hpp>
#include <boost/fusion/adapted/class/detail/category_of_impl.hpp> #include <boost/fusion/adapted/class/detail/category_of_impl.hpp>
#include <boost/fusion/adapted/class/detail/size_impl.hpp>
#include <boost/fusion/adapted/class/detail/begin_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/end_impl.hpp>
#include <boost/fusion/adapted/class/detail/size_impl.hpp> #include <boost/fusion/adapted/class/detail/value_of_impl.hpp>
#include <boost/fusion/adapted/class/detail/at_impl.hpp> #include <boost/fusion/adapted/class/detail/deref_impl.hpp>
#include <boost/fusion/adapted/class/detail/value_at_impl.hpp> #include <boost/fusion/adapted/class/detail/deref_data_impl.hpp>
#include <boost/fusion/adapted/class/detail/has_key_impl.hpp> #include <boost/fusion/adapted/class/detail/key_of_impl.hpp>
#include <boost/fusion/adapted/class/detail/at_key_impl.hpp> #include <boost/fusion/adapted/class/detail/value_of_data_impl.hpp>
#include <boost/fusion/adapted/class/detail/value_at_key_impl.hpp>
#include <boost/preprocessor/cat.hpp> #define BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_0(A, B, C, D, E)\
#include <boost/preprocessor/punctuation/comma_if.hpp> ((A, B, C, D, E)) BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_1
#include <boost/preprocessor/seq/for_each_i.hpp> #define BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_1(A, B, C, D, E)\
#include <boost/preprocessor/tuple/elem.hpp> ((A, B, C, D, E)) BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_0
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> #define BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_0_END
#include <boost/preprocessor/repetition/enum_params.hpp> #define BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_1_END
#include <boost/preprocessor/cat.hpp>
#include <boost/mpl/int.hpp>
#include <boost/config/no_tr1/utility.hpp>
namespace boost { namespace fusion { namespace extension { #define BOOST_FUSION_ADAPT_ASSOC_CLASS_C( \
template<typename Class, typename Key> TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE) \
struct class_assoc_member;
}}}
#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; \
}; \
}}} \
\ \
namespace boost { namespace mpl \ BOOST_FUSION_ADAPT_CLASS_C_BASE(TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,ATTRIBUTE,5) \
{ \
template<typename> \
struct sequence_tag; \
\ \
template<> \ template< \
struct sequence_tag<name> \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ) \
{ \ > \
typedef fusion::fusion_sequence_tag type; \ struct struct_assoc_key<BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ), I> \
}; \
\
template<> \
struct sequence_tag<name const> \
{ \
typedef fusion::fusion_sequence_tag type; \
}; \
}} \
\
namespace boost { namespace fusion { namespace extension \
{ \ { \
template <> \ typedef BOOST_PP_TUPLE_ELEM(5, 4, ATTRIBUTE) type; \
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); \
}; \
}; };
/***/
#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_class_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_class_tag, \
BOOST_PP_CAT(BOOST_FUSION_ADAPT_ASSOC_CLASS_FILLER_0 ATTRIBUTES,_END), \
BOOST_FUSION_ADAPT_ASSOC_CLASS_C)
#endif #endif

28
include/boost/fusion/adapted/class/adapt_assoc_class_named.hpp Normal file
View File

@ -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

151
include/boost/fusion/adapted/class/adapt_class.hpp
View File

@ -1,132 +1,55 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2009 Joel de Guzman Copyright (c) 2010 Christopher Schmidt
Copyright (c) 2009-2010 Hartmut Kaiser
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_CLASS_ADAPT_CLASS_HPP
#include <boost/fusion/adapted/class/extension.hpp> #define BOOST_FUSION_ADAPTED_CLASS_ADAPT_CLASS_HPP
#include <boost/fusion/adapted/class/class_iterator.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/empty.hpp>
#include <boost/fusion/adapted/class/detail/extension.hpp>
#include <boost/fusion/adapted/class/detail/adapt_base.hpp>
#include <boost/fusion/adapted/class/detail/at_impl.hpp>
#include <boost/fusion/adapted/class/detail/is_view_impl.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/is_sequence_impl.hpp>
#include <boost/fusion/adapted/class/detail/value_at_impl.hpp>
#include <boost/fusion/adapted/class/detail/category_of_impl.hpp> #include <boost/fusion/adapted/class/detail/category_of_impl.hpp>
#include <boost/fusion/adapted/class/detail/size_impl.hpp>
#include <boost/fusion/adapted/class/detail/begin_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/end_impl.hpp>
#include <boost/fusion/adapted/class/detail/size_impl.hpp> #include <boost/fusion/adapted/class/detail/value_of_impl.hpp>
#include <boost/fusion/adapted/class/detail/at_impl.hpp> #include <boost/fusion/adapted/class/detail/deref_impl.hpp>
#include <boost/fusion/adapted/class/detail/value_at_impl.hpp>
#include <boost/preprocessor/cat.hpp> #define BOOST_FUSION_ADAPT_CLASS_FILLER_0(A, B, C, D)\
#include <boost/preprocessor/punctuation/comma_if.hpp> ((A, B, C, D)) BOOST_FUSION_ADAPT_CLASS_FILLER_1
#include <boost/preprocessor/seq/for_each_i.hpp> #define BOOST_FUSION_ADAPT_CLASS_FILLER_1(A, B, C, D)\
#include <boost/preprocessor/tuple/elem.hpp> ((A, B, C, D)) BOOST_FUSION_ADAPT_CLASS_FILLER_0
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> #define BOOST_FUSION_ADAPT_CLASS_FILLER_0_END
#include <boost/preprocessor/repetition/enum_params.hpp> #define BOOST_FUSION_ADAPT_CLASS_FILLER_1_END
#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>
#define BOOST_FUSION_ADAPT_CLASS(name, bseq) \ #define BOOST_FUSION_ADAPT_CLASS_C(TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE) \
BOOST_FUSION_ADAPT_CLASS_I( \ BOOST_FUSION_ADAPT_CLASS_C_BASE( \
name, BOOST_PP_CAT(BOOST_FUSION_ADAPT_CLASS_X bseq, 0)) \ TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE, 4)
/***/
#define BOOST_FUSION_ADAPT_CLASS_X(w, x, y, z) ((w, x, y, z)) BOOST_FUSION_ADAPT_CLASS_Y #define BOOST_FUSION_ADAPT_TPL_CLASS(TEMPLATE_PARAMS_SEQ, NAME_SEQ , ATTRIBUTES)\
#define BOOST_FUSION_ADAPT_CLASS_Y(w, x, y, z) ((w, x, y, z)) BOOST_FUSION_ADAPT_CLASS_X BOOST_FUSION_ADAPT_STRUCT_BASE( \
#define BOOST_FUSION_ADAPT_CLASS_X0 (1)TEMPLATE_PARAMS_SEQ, \
#define BOOST_FUSION_ADAPT_CLASS_Y0 (1)NAME_SEQ, \
class_tag, \
BOOST_PP_CAT(BOOST_FUSION_ADAPT_CLASS_FILLER_0 ATTRIBUTES,_END), \
BOOST_FUSION_ADAPT_CLASS_C)
// BOOST_FUSION_ADAPT_CLASS_I generates the overarching structure and uses #define BOOST_FUSION_ADAPT_CLASS(NAME, ATTRIBUTES) \
// SEQ_FOR_EACH_I to generate the "linear" substructures. BOOST_FUSION_ADAPT_STRUCT_BASE( \
// Thanks to Paul Mensonides for the PP macro help (0), \
(0)(NAME), \
#define BOOST_FUSION_ADAPT_CLASS_I(name, seq) \ class_tag, \
namespace boost { namespace fusion { namespace traits \ BOOST_PP_CAT(BOOST_FUSION_ADAPT_CLASS_FILLER_0 ATTRIBUTES,_END), \
{ \ BOOST_FUSION_ADAPT_CLASS_C)
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_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); \
} \
}; \
/***/
#endif #endif

162
include/boost/fusion/adapted/class/adapt_class_named.hpp
View File

@ -1,156 +1,28 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2009 Joel de Guzman Copyright (c) 2010 Christopher Schmidt
Copyright (c) 2009-2010 Hartmut Kaiser
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_CLASS_ADAPT_CLASS_NAMED_HPP
#include <boost/fusion/adapted/class/extension.hpp> #define BOOST_FUSION_ADAPTED_CLASS_ADAPT_CLASS_NAMED_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/preprocessor/cat.hpp> #include <boost/fusion/adapted/class/adapt_class.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp> #include <boost/fusion/adapted/struct/detail/proxy_type.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>
#define BOOST_FUSION_ADAPT_CLASS_NAMED(name, newname, bseq) \ #define BOOST_FUSION_ADAPT_CLASS_NAMED_NS( \
BOOST_FUSION_ADAPT_CLASS_NAMED_I(name, (boost)(fusion)(adapted), newname, \ WRAPPED_TYPE, NAMESPACE_SEQ, NAME, ATTRIBUTES) \
BOOST_PP_CAT(BOOST_FUSION_ADAPT_CLASS_NAMED_X bseq, 0)) \ \
/***/ 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) \ #define BOOST_FUSION_ADAPT_CLASS_NAMED(WRAPPED_TYPE, NAME, ATTRIBUTES) \
BOOST_FUSION_ADAPT_CLASS_NAMED_I(name, ns, newname, \ BOOST_FUSION_ADAPT_CLASS_NAMED_NS( \
BOOST_PP_CAT(BOOST_FUSION_ADAPT_CLASS_NAMED_X bseq, 0)) \ WRAPPED_TYPE,(boost)(fusion)(adapted),NAME,ATTRIBUTES)
/***/
#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); \
} \
}; \
/***/
#endif #endif

105
include/boost/fusion/adapted/class/class_iterator.hpp
View File

@ -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

83
include/boost/fusion/adapted/class/detail/adapt_base.hpp Normal file
View File

@ -0,0 +1,83 @@
/*=============================================================================
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_DETAIL_CLASS_ADAPT_BASE_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_CLASS_ADAPT_BASE_HPP
#include <boost/fusion/adapted/struct/detail/adapt_base.hpp>
#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) \
type; \
\
class_member_proxy(BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj)\
: obj(obj) \
{} \
\
template<class Arg> \
class_member_proxy& \
operator=(Arg val) \
{ \
BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 3, ATTRIBUTE); \
return *this; \
} \
\
operator type() \
{ \
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) type; \
typedef \
BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 1, ATTRIBUTE) \
get_type; \
typedef \
class_member_proxy< \
BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) \
, I \
> \
proxy; \
\
static get_type \
call(BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) const& obj) \
{ \
return BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 2, ATTRIBUTE); \
}; \
\
static proxy \
call(BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj) \
{ \
return proxy(obj); \
}; \
};
namespace boost { namespace fusion { namespace extension
{
template <typename T, int N>
struct class_member_proxy;
}}}
#endif

95
include/boost/fusion/adapted/class/detail/at_impl.hpp
View File

@ -1,70 +1,55 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2009 Joel de Guzman Copyright (c) 2010 Christopher Schmidt
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_DETAIL_CLASS_AT_IMPL_HPP
#include <boost/mpl/assert.hpp> #define BOOST_FUSION_ADAPTED_DETAIL_CLASS_AT_IMPL_HPP
#include <boost/mpl/int.hpp>
namespace boost { namespace fusion #include <boost/mpl/if.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/remove_const.hpp>
namespace boost { namespace fusion { namespace extension
{ {
struct class_tag; template<typename>
struct at_impl;
namespace extension template <>
struct at_impl<class_tag>
{ {
template<typename T> template<typename Seq, typename N>
struct at_impl; struct apply
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> typedef
struct apply extension::struct_member<
typename remove_const<Seq>::type
, N::value
>
member;
typedef typename
mpl::if_<
is_const<Seq>
, typename member::get_type
, typename member::proxy
>::type
type;
static type
call(Seq& seq)
{ {
static int const n_value = N::value; return member::call(seq);
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);
//~ }
};
}; };
} };
}}
template <>
struct at_impl<assoc_class_tag>
: at_impl<class_tag>
{};
}}}
#endif #endif

54
include/boost/fusion/adapted/class/detail/at_key_impl.hpp
View File

@ -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

75
include/boost/fusion/adapted/class/detail/begin_impl.hpp
View File

@ -1,40 +1,65 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2009 Joel de Guzman Copyright (c) 2010 Christopher Schmidt
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_DETAIL_CLASS_BEGIN_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_CLASS_BEGIN_IMPL_HPP
namespace boost { namespace fusion #include <boost/fusion/iterator/basic_iterator.hpp>
namespace boost { namespace fusion { namespace extension
{ {
struct class_tag; template<typename>
struct begin_impl;
namespace extension template <>
struct begin_impl<class_tag>
{ {
template<typename T> template <typename Seq>
struct begin_impl; struct apply
template <>
struct begin_impl<class_tag>
{ {
template <typename Sequence> typedef
struct apply basic_iterator<
{ class_iterator_tag
typedef class_iterator<Sequence, 0> type; , random_access_traversal_tag
, Seq
, 0
>
type;
static type static type
call(Sequence& v) call(Seq& seq)
{ {
return type(v); return type(seq,0);
} }
};
}; };
} };
}}
template <>
struct begin_impl<assoc_class_tag>
{
template <typename Seq>
struct apply
{
typedef
basic_iterator<
assoc_class_iterator_tag
, assoc_class_category
, Seq
, 0
>
type;
static type
call(Seq& seq)
{
return type(seq,0);
}
};
};
}}}
#endif #endif

29
include/boost/fusion/adapted/class/detail/category_of_impl.hpp
View File

@ -1,34 +1,31 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2009 Joel de Guzman Copyright (c) 2010 Christopher Schmidt
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_DETAIL_CLASS_CATEGORY_OF_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_CLASS_CATEGORY_OF_IMPL_HPP
#include <boost/fusion/adapted/struct/detail/category_of_impl.hpp>
namespace boost { namespace fusion namespace boost { namespace fusion
{ {
struct class_tag;
struct random_access_traversal_tag;
namespace extension namespace extension
{ {
template<typename T> template<typename>
struct category_of_impl; struct category_of_impl;
template<> template<>
struct category_of_impl<class_tag> struct category_of_impl<class_tag>
{ : category_of_impl<struct_tag>
template<typename T> {};
struct apply
{ template<>
typedef random_access_traversal_tag type; struct category_of_impl<assoc_class_tag>
}; : category_of_impl<assoc_struct_tag>
}; {};
} }
}} }}

22
include/boost/fusion/adapted/class/detail/deref_data_impl.hpp Normal file
View File

@ -0,0 +1,22 @@
/*=============================================================================
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_DETAIL_CLASS_DEREF_DATA_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_CLASS_DEREF_DATA_IMPL_HPP
namespace boost { namespace fusion { namespace extension
{
template <typename>
struct deref_data_impl;
template <>
struct deref_data_impl<assoc_class_iterator_tag>
: deref_impl<assoc_class_iterator_tag>
{};
}}}
#endif

55
include/boost/fusion/adapted/class/detail/deref_impl.hpp Normal file
View File

@ -0,0 +1,55 @@
/*=============================================================================
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_DETAIL_CLASS_DEREF_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_CLASS_DEREF_IMPL_HPP
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/remove_const.hpp>
namespace boost { namespace fusion { namespace extension
{
template <typename>
struct deref_impl;
template <>
struct deref_impl<class_iterator_tag>
{
template <typename It>
struct apply
{
typedef
extension::struct_member<
typename remove_const<typename It::seq_type>::type
, It::index::value
>
member;
typedef typename
mpl::if_<
is_const<typename It::seq_type>
, typename member::get_type
, typename member::proxy
>::type
type;
static type
call(It const& it)
{
return member::call(*it.seq);
}
};
};
template <>
struct deref_impl<assoc_class_iterator_tag>
: deref_impl<class_iterator_tag>
{};
}}}
#endif

84
include/boost/fusion/adapted/class/detail/end_impl.hpp
View File

@ -1,48 +1,66 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2009 Joel de Guzman Copyright (c) 2010 Christopher Schmidt
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_DETAIL_CLASS_END_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_CLASS_END_IMPL_HPP
namespace boost { namespace fusion #include <boost/fusion/iterator/basic_iterator.hpp>
#include <boost/type_traits/remove_const.hpp>
namespace boost { namespace fusion { namespace extension
{ {
struct class_tag; template <typename>
struct end_impl;
namespace extension template <>
struct end_impl<class_tag>
{ {
template <typename Tag> template <typename Seq>
struct end_impl; struct apply
template <typename Class>
struct class_size;
template <>
struct end_impl<class_tag>
{ {
template <typename Sequence> typedef
struct apply basic_iterator<
{ class_iterator_tag
typedef , random_access_traversal_tag
class_iterator< , Seq
Sequence , struct_size<typename remove_const<Seq>::type>::value
, class_size<Sequence>::value >
> type;
type;
static type static type
call(Sequence& v) call(Seq& seq)
{ {
return type(v); return type(seq,0);
} }
};
}; };
} };
}}
template <>
struct end_impl<assoc_class_tag>
{
template <typename Seq>
struct apply
{
typedef
basic_iterator<
assoc_class_iterator_tag
, assoc_class_category
, Seq
, struct_size<typename remove_const<Seq>::type>::value
>
type;
static type
call(Seq& seq)
{
return type(seq,0);
}
};
};
}}}
#endif #endif

23
include/boost/fusion/adapted/class/detail/extension.hpp Normal file
View File

@ -0,0 +1,23 @@
/*=============================================================================
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_DETAIL_CLASS_EXTENSION_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_CLASS_EXTENSION_HPP
#include <boost/fusion/adapted/struct/detail/extension.hpp>
namespace boost { namespace fusion
{
struct class_tag;
struct class_iterator_tag;
struct assoc_class_tag;
struct assoc_class_iterator_tag;
typedef assoc_struct_category assoc_class_category;
}}
#endif

40
include/boost/fusion/adapted/class/detail/has_key_impl.hpp
View File

@ -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

36
include/boost/fusion/adapted/class/detail/is_sequence_impl.hpp
View File

@ -1,31 +1,29 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2009 Joel de Guzman Copyright (c) 2010 Christopher Schmidt
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_DETAIL_CLASS_IS_SEQUENCE_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_CLASS_IS_SEQUENCE_IMPL_HPP
namespace boost { namespace fusion #include <boost/fusion/adapted/struct/detail/is_sequence_impl.hpp>
namespace boost { namespace fusion { namespace extension
{ {
struct class_tag; template<typename>
struct is_sequence_impl;
namespace extension template<>
{ struct is_sequence_impl<class_tag>
template<typename Tag> : is_sequence_impl<struct_tag>
struct is_sequence_impl; {};
template<> template <>
struct is_sequence_impl<class_tag> struct is_sequence_impl<assoc_class_tag>
{ : is_sequence_impl<assoc_struct_tag>
template<typename Sequence> {};
struct apply : mpl::true_ {}; }}}
};
}
}}
#endif #endif

37
include/boost/fusion/adapted/class/detail/is_view_impl.hpp
View File

@ -1,32 +1,29 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2009 Joel de Guzman Copyright (c) 2010 Christopher Schmidt
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_DETAIL_CLASS_IS_VIEW_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_CLASS_IS_VIEW_IMPL_HPP
namespace boost { namespace fusion #include <boost/fusion/adapted/struct/detail/is_view_impl.hpp>
namespace boost { namespace fusion { namespace extension
{ {
struct class_tag; template<typename>
struct is_view_impl;
namespace extension template<>
{ struct is_view_impl<class_tag>
template<typename Tag> : is_view_impl<struct_tag>
struct is_view_impl; {};
template<> template <>
struct is_view_impl<class_tag> struct is_view_impl<assoc_class_tag>
{ : is_view_impl<assoc_struct_tag>
template<typename T> {};
struct apply : mpl::false_ }}}
{};
};
}
}}
#endif #endif

24
include/boost/fusion/adapted/class/detail/key_of_impl.hpp Normal file
View File

@ -0,0 +1,24 @@
/*=============================================================================
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_DETAIL_CLASS_KEY_OF_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_CLASS_KEY_OF_IMPL_HPP
#include <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<assoc_class_iterator_tag>
: key_of_impl<assoc_struct_iterator_tag>
{};
}}}
#endif

42
include/boost/fusion/adapted/class/detail/size_impl.hpp
View File

@ -1,37 +1,29 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2009 Joel de Guzman Copyright (c) 2010 Christopher Schmidt
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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_DETAIL_CLASS_SIZE_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_CLASS_SIZE_IMPL_HPP
namespace boost { namespace fusion #include <boost/fusion/adapted/struct/detail/size_impl.hpp>
namespace boost { namespace fusion { namespace extension
{ {
namespace extension template<typename>
{ struct size_impl;
template <typename Class>
struct class_size;
}
struct class_tag; template <>
struct size_impl<class_tag>
: size_impl<struct_tag>
{};
namespace extension template <>
{ struct size_impl<assoc_class_tag>
template<typename T> : size_impl<assoc_struct_tag>
struct size_impl; {};
}}}
template <>
struct size_impl<class_tag>
{
template <typename Sequence>
struct apply : extension::class_size<Sequence> {};
};
}
}}
#endif #endif

52
include/boost/fusion/adapted/class/detail/value_at_impl.hpp
View File

@ -1,47 +1,29 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2009 Joel de Guzman Copyright (c) 2010 Christopher Schmidt
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_DETAIL_CLASS_VALUE_AT_IMPL_HPP
#include <boost/static_assert.hpp> #define BOOST_FUSION_ADAPTED_DETAIL_CLASS_VALUE_AT_IMPL_HPP
namespace boost { namespace fusion #include <boost/fusion/adapted/struct/detail/value_at_impl.hpp>
namespace boost { namespace fusion { namespace extension
{ {
struct class_tag; template<typename>
struct value_at_impl;
namespace extension template <>
{ struct value_at_impl<class_tag>
template<typename T> : value_at_impl<struct_tag>
struct value_at_impl; {};
template <typename Class, int N> template <>
struct class_member; struct value_at_impl<assoc_class_tag>
: value_at_impl<assoc_struct_tag>
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 #endif

39
include/boost/fusion/adapted/class/detail/value_at_key_impl.hpp
View File

@ -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

24
include/boost/fusion/adapted/class/detail/value_of_data_impl.hpp Normal file
View File

@ -0,0 +1,24 @@
/*=============================================================================
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_DETAIL_CLASS_VALUE_OF_DATA_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_CLASS_VALUE_OF_DATA_IMPL_HPP
#include <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<assoc_class_iterator_tag>
: value_of_data_impl<assoc_struct_iterator_tag>
{};
}}}
#endif

29
include/boost/fusion/adapted/class/detail/value_of_impl.hpp Normal file
View File

@ -0,0 +1,29 @@
/*=============================================================================
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_DETAIL_CLASS_VALUE_OF_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_CLASS_VALUE_OF_IMPL_HPP
#include <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<class_iterator_tag>
: value_of_impl<struct_iterator_tag>
{};
template <>
struct value_of_impl<assoc_class_iterator_tag>
: value_of_impl<class_iterator_tag>
{};
}}}
#endif

61
include/boost/fusion/adapted/class/extension.hpp
View File

@ -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

87
include/boost/fusion/adapted/std_pair.hpp
View File

@ -1,89 +1,24 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2005-2006 Dan Marsden
Copyright (c) 2009-2010 Christopher Schmidt
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_STD_PAIR_HPP
#include <boost/fusion/adapted/struct.hpp> #define BOOST_FUSION_ADAPTED_STD_PAIR_HPP
#include <boost/mpl/int.hpp>
#include <boost/config/no_tr1/utility.hpp>
namespace boost { namespace fusion #include <boost/fusion/adapted/struct/adapt_struct.hpp>
namespace std
{ {
struct struct_tag; template<class T1, class T2>
struct fusion_sequence_tag; struct pair;
}
namespace traits BOOST_FUSION_ADAPT_TPL_STRUCT(
{ (T1)(T2),(std::pair)(T1)(T2),(T1, first)(T2, second))
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>
{
};
}}}
#endif #endif

71
include/boost/fusion/adapted/std_pair/detail/at_impl.hpp
View File

@ -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

40
include/boost/fusion/adapted/std_pair/detail/begin_impl.hpp
View File

@ -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

35
include/boost/fusion/adapted/std_pair/detail/category_of_impl.hpp
View File

@ -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

40
include/boost/fusion/adapted/std_pair/detail/end_impl.hpp
View File

@ -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

31
include/boost/fusion/adapted/std_pair/detail/is_sequence_impl.hpp
View File

@ -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

32
include/boost/fusion/adapted/std_pair/detail/is_view_impl.hpp
View File

@ -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

31
include/boost/fusion/adapted/std_pair/detail/size_impl.hpp
View File

@ -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

43
include/boost/fusion/adapted/std_pair/detail/value_at_impl.hpp
View File

@ -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

127
include/boost/fusion/adapted/std_pair/std_pair_iterator.hpp
View File

@ -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

48
include/boost/fusion/adapted/std_pair/tag_of.hpp
View File

@ -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

25
include/boost/fusion/adapted/struct.hpp
View File

@ -1,29 +1,18 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2005-2006 Dan Marsden
Copyright (c) 2009-2010 Christopher Schmidt
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_STRUCT_HPP
#include <boost/fusion/adapted/struct/adapt_struct.hpp> #define BOOST_FUSION_ADAPTED_STRUCT_HPP
#include <boost/fusion/adapted/struct/adapt_struct_named.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/adapt_assoc_struct.hpp>
#include <boost/fusion/adapted/struct/struct_iterator.hpp> #include <boost/fusion/adapted/struct/adapt_struct_named.hpp>
#include <boost/fusion/adapted/struct/adapt_struct.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>
#endif #endif

149
include/boost/fusion/adapted/struct/adapt_assoc_struct.hpp
View File

@ -1,113 +1,78 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2007 Joel de Guzman Copyright (c) 2001-2007 Joel de Guzman
Copyright (c) 2007 Dan Marsden Copyright (c) 2007 Dan Marsden
Copyright (c) 2009-2010 Christopher Schmidt
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_STRUCT_ADAPT_ASSOC_STRUCT_HPP
#include <boost/fusion/adapted/struct/extension.hpp> #define BOOST_FUSION_ADAPTED_STRUCT_ADAPT_ASSOC_STRUCT_HPP
#include <boost/fusion/adapted/struct/struct_iterator.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/empty.hpp>
#include <boost/preprocessor/tuple/elem.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_view_impl.hpp>
#include <boost/fusion/adapted/struct/detail/is_sequence_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/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/begin_impl.hpp>
#include <boost/fusion/adapted/struct/detail/end_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/value_of_impl.hpp>
#include <boost/fusion/adapted/struct/detail/at_impl.hpp> #include <boost/fusion/adapted/struct/detail/deref_impl.hpp>
#include <boost/fusion/adapted/struct/detail/value_at_impl.hpp> #include <boost/fusion/adapted/struct/detail/deref_data_impl.hpp>
#include <boost/fusion/adapted/struct/detail/has_key_impl.hpp> #include <boost/fusion/adapted/struct/detail/key_of_impl.hpp>
#include <boost/fusion/adapted/struct/detail/at_key_impl.hpp> #include <boost/fusion/adapted/struct/detail/value_of_data_impl.hpp>
#include <boost/fusion/adapted/struct/detail/value_at_key_impl.hpp>
#include <boost/preprocessor/cat.hpp> #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0(X, Y, Z)\
#include <boost/preprocessor/punctuation/comma_if.hpp> ((X, Y, Z)) BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_1
#include <boost/preprocessor/seq/for_each_i.hpp> #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_1(X, Y, Z)\
#include <boost/preprocessor/tuple/elem.hpp> ((X, Y, Z)) BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0_END
#include <boost/preprocessor/repetition/enum_params.hpp> #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_1_END
#include <boost/preprocessor/cat.hpp>
#include <boost/mpl/int.hpp>
#include <boost/config/no_tr1/utility.hpp>
namespace boost { namespace fusion { namespace extension { #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_C_BASE( \
template<typename Struct, typename Key> TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,PREFIX,ATTRIBUTE) \
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; \
}; \
}}} \
\ \
namespace boost { namespace mpl \ BOOST_FUSION_ADAPT_STRUCT_C_BASE( \
{ \ TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, PREFIX, ATTRIBUTE, 3) \
template<typename> \
struct sequence_tag; \
\ \
template<> \ template< \
struct sequence_tag<name> \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ) \
{ \ > \
typedef fusion::fusion_sequence_tag type; \ struct struct_assoc_key<BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ), I> \
}; \
\
template<> \
struct sequence_tag<name const> \
{ \
typedef fusion::fusion_sequence_tag type; \
}; \
}} \
\
namespace boost { namespace fusion { namespace extension \
{ \ { \
template <> \ typedef BOOST_PP_TUPLE_ELEM(3, 2, ATTRIBUTE) type; \
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); \
}; \
}; };
/***/
#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 #endif

38
include/boost/fusion/adapted/struct/adapt_assoc_struct_named.hpp Normal file
View File

@ -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

113
include/boost/fusion/adapted/struct/adapt_struct.hpp
View File

@ -1,94 +1,55 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2007 Joel de Guzman Copyright (c) 2001-2007 Joel de Guzman
Copyright (c) 2009-2010 Christopher Schmidt
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_STRUCT_ADAPT_STRUCT_HPP
#include <boost/fusion/adapted/struct/extension.hpp> #define BOOST_FUSION_ADAPTED_STRUCT_ADAPT_STRUCT_HPP
#include <boost/fusion/adapted/struct/struct_iterator.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/empty.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_view_impl.hpp>
#include <boost/fusion/adapted/struct/detail/is_sequence_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/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/begin_impl.hpp>
#include <boost/fusion/adapted/struct/detail/end_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/value_of_impl.hpp>
#include <boost/fusion/adapted/struct/detail/at_impl.hpp> #include <boost/fusion/adapted/struct/detail/deref_impl.hpp>
#include <boost/fusion/adapted/struct/detail/value_at_impl.hpp>
#include <boost/preprocessor/cat.hpp> #define BOOST_FUSION_ADAPT_STRUCT_FILLER_0(X, Y) \
#include <boost/preprocessor/punctuation/comma_if.hpp> ((X, Y)) BOOST_FUSION_ADAPT_STRUCT_FILLER_1
#include <boost/preprocessor/seq/for_each_i.hpp> #define BOOST_FUSION_ADAPT_STRUCT_FILLER_1(X, Y) \
#include <boost/preprocessor/tuple/elem.hpp> ((X, Y)) BOOST_FUSION_ADAPT_STRUCT_FILLER_0
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> #define BOOST_FUSION_ADAPT_STRUCT_FILLER_0_END
#include <boost/preprocessor/repetition/enum_params.hpp> #define BOOST_FUSION_ADAPT_STRUCT_FILLER_1_END
#include <boost/preprocessor/cat.hpp>
#include <boost/mpl/int.hpp>
#include <boost/config/no_tr1/utility.hpp>
#define BOOST_FUSION_ADAPT_STRUCT(name, bseq) \ #define BOOST_FUSION_ADAPT_STRUCT_C(TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE)\
BOOST_FUSION_ADAPT_STRUCT_I( \ BOOST_FUSION_ADAPT_STRUCT_C_BASE( \
name, BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_X bseq, 0)) \ 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_TPL_STRUCT(TEMPLATE_PARAMS_SEQ,NAME_SEQ, ATTRIBUTES) \
#define BOOST_FUSION_ADAPT_STRUCT_Y(x, y) ((x, y)) BOOST_FUSION_ADAPT_STRUCT_X BOOST_FUSION_ADAPT_STRUCT_BASE( \
#define BOOST_FUSION_ADAPT_STRUCT_X0 (1)TEMPLATE_PARAMS_SEQ, \
#define BOOST_FUSION_ADAPT_STRUCT_Y0 (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 #define BOOST_FUSION_ADAPT_STRUCT(NAME, ATTRIBUTES) \
// SEQ_FOR_EACH_I to generate the "linear" substructures. BOOST_FUSION_ADAPT_STRUCT_BASE( \
// Thanks to Paul Mensonides for the PP macro help (0), \
(0)(NAME), \
#define BOOST_FUSION_ADAPT_STRUCT_I(name, seq) \ struct_tag, \
namespace boost { namespace fusion { namespace traits \ BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_FILLER_0 ATTRIBUTES,_END), \
{ \ BOOST_FUSION_ADAPT_STRUCT_C)
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); \
}; \
}; \
/***/
#endif #endif

141
include/boost/fusion/adapted/struct/adapt_struct_named.hpp
View File

@ -1,128 +1,39 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2007 Joel de Guzman Copyright (c) 2010 Christopher Schmidt
Copyright (c) 2009-2010 Hartmut Kaiser
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_STRUCT_ADAPT_STRUCT_NAMED_HPP
#include <boost/fusion/adapted/struct/extension.hpp> #define BOOST_FUSION_ADAPTED_STRUCT_ADAPT_STRUCT_NAMED_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>
#include <boost/preprocessor/cat.hpp> #include <boost/fusion/adapted/struct/adapt_struct.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp> #include <boost/fusion/adapted/struct/detail/proxy_type.hpp>
#include <boost/preprocessor/seq/for_each.hpp> #include <boost/preprocessor/empty.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>
#define BOOST_FUSION_ADAPT_STRUCT_NAMED(name, newname, bseq) \ #define BOOST_FUSION_ADAPT_STRUCT_NAMED_C( \
BOOST_FUSION_ADAPT_STRUCT_NAMED_I(name, (boost)(fusion)(adapted), newname, \ TEMPLATE_PARAMS_SEQ, NAME_SEQ, I, ATTRIBUTE) \
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) \
\ \
namespace boost { namespace fusion { namespace traits \ BOOST_FUSION_ADAPT_STRUCT_C_BASE( \
{ \ TEMPLATE_PARAMS_SEQ,NAME_SEQ, I, obj., ATTRIBUTE, 2)
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) \
}}} \
/***/
#define BOOST_FUSION_ADAPT_STRUCT_NAMED_NAME(ns, newname) \ #define BOOST_FUSION_ADAPT_STRUCT_NAMED_NS( \
BOOST_PP_SEQ_FOR_EACH_R(1, BOOST_FUSION_ADAPT_STRUCT_NAMED_NS_D, _, ns) \ WRAPPED_TYPE, NAMESPACE_SEQ, NAME, ATTRIBUTES) \
newname \ \
/***/ 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(WRAPPED_TYPE, NAME, ATTRIBUTES) \
#define BOOST_FUSION_ADAPT_STRUCT_NAMED_NS_D(r, _, ns) ns:: BOOST_FUSION_ADAPT_STRUCT_NAMED_NS( \
#define BOOST_FUSION_ADAPT_STRUCT_NAMED_NS_E(r, _, ns) } WRAPPED_TYPE,(boost)(fusion)(adapted),NAME,ATTRIBUTES)
#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); \
} \
}; \
/***/
#endif #endif

169
include/boost/fusion/adapted/struct/detail/adapt_base.hpp Normal file
View File

@ -0,0 +1,169 @@
/*=============================================================================
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_DETAIL_STRUCT_ADAPT_BASE_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_ADAPT_BASE_HPP
#include <boost/config.hpp>
#include <boost/fusion/support/tag_of_fwd.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/type_traits/add_reference.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))>
#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> \
static typename add_reference<type>::type \
call(Seq& seq) \
{ \
return seq.PREFIX \
BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 1, ATTRIBUTE); \
} \
\
template<typename Seq> \
static typename add_reference<typename add_const<type>::type>::type \
call(Seq const& seq) \
{ \
return seq.PREFIX \
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

85
include/boost/fusion/adapted/struct/detail/at_impl.hpp
View File

@ -1,63 +1,58 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2005-2006 Dan Marsden
Copyright (c) 2009-2010 Christopher Schmidt
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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 #ifndef BOOST_FUSION_ADAPTED_DETAIL_STRUCT_AT_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_AT_IMPL_HPP
#include <boost/fusion/support/detail/access.hpp> #include <boost/fusion/support/detail/access.hpp>
#include <boost/mpl/assert.hpp> #include <boost/mpl/eval_if.hpp>
#include <boost/mpl/int.hpp> #include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/is_const.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> template <typename Seq, typename N>
struct at_impl; struct apply
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> typedef
struct apply extension::struct_member<
typename remove_const<Seq>::type
, N::value
>
member;
typedef typename
mpl::eval_if<
is_const<Seq>
, detail::cref_result<member>
, detail::ref_result<member>
>::type
type;
static type
call(Seq& seq)
{ {
static int const n_value = N::value; return member::call(seq);
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 #endif

54
include/boost/fusion/adapted/struct/detail/at_key_impl.hpp
View File

@ -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

73
include/boost/fusion/adapted/struct/detail/begin_impl.hpp
View File

@ -1,40 +1,67 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2005-2006 Dan Marsden
Copyright (c) 2009-2010 Christopher Schmidt
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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_DETAIL_STRUCT_BEGIN_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_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> template <typename Seq>
struct begin_impl; struct apply
template <>
struct begin_impl<struct_tag>
{ {
template <typename Sequence> typedef
struct apply basic_iterator<
{ struct_iterator_tag
typedef struct_iterator<Sequence, 0> type; , random_access_traversal_tag
, Seq
, 0
>
type;
static type static type
call(Sequence& v) call(Seq& seq)
{ {
return type(v); return type(seq,0);
} }
};
}; };
} };
}}
template <>
struct begin_impl<assoc_struct_tag>
{
template <typename Seq>
struct apply
{
typedef
basic_iterator<
assoc_struct_iterator_tag
, assoc_struct_category
, Seq
, 0
>
type;
static type
call(Seq& seq)
{
return type(seq,0);
}
};
};
}}}
#endif #endif

23
include/boost/fusion/adapted/struct/detail/category_of_impl.hpp
View File

@ -1,34 +1,41 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2005-2006 Dan Marsden
Copyright (c) 2009-2010 Christopher Schmidt
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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_DETAIL_STRUCT_CATEGORY_OF_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_CATEGORY_OF_IMPL_HPP
namespace boost { namespace fusion namespace boost { namespace fusion
{ {
struct struct_tag;
struct random_access_traversal_tag;
namespace extension namespace extension
{ {
template<typename T> template<typename>
struct category_of_impl; struct category_of_impl;
template<> template<>
struct category_of_impl<struct_tag> struct category_of_impl<struct_tag>
{ {
template<typename T> template<typename Seq>
struct apply struct apply
{ {
typedef random_access_traversal_tag type; typedef random_access_traversal_tag type;
}; };
}; };
template<>
struct category_of_impl<assoc_struct_tag>
{
template<typename Seq>
struct apply
{
typedef assoc_struct_category type;
};
};
} }
}} }}

22
include/boost/fusion/adapted/struct/detail/deref_data_impl.hpp Normal file
View File

@ -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_DETAIL_STRUCT_DEREF_DATA_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_DEREF_DATA_IMPL_HPP
namespace boost { namespace fusion { namespace extension
{
template <typename>
struct deref_data_impl;
template <>
struct deref_data_impl<assoc_struct_iterator_tag>
: deref_impl<assoc_struct_iterator_tag>
{};
}}}
#endif

56
include/boost/fusion/adapted/struct/detail/deref_impl.hpp Normal file
View File

@ -0,0 +1,56 @@
/*=============================================================================
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_DETAIL_STRUCT_DEREF_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_DEREF_IMPL_HPP
#include <boost/fusion/support/detail/access.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/is_const.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
extension::struct_member<
typename remove_const<typename It::seq_type>::type
, It::index::value
>
member;
typedef typename
mpl::eval_if<
is_const<typename It::seq_type>
, detail::cref_result<member>
, detail::ref_result<member>
>::type
type;
static type
call(It const& it)
{
return member::call(*it.seq);
}
};
};
template <>
struct deref_impl<assoc_struct_iterator_tag>
: deref_impl<struct_iterator_tag>
{};
}}}
#endif

82
include/boost/fusion/adapted/struct/detail/end_impl.hpp
View File

@ -1,48 +1,68 @@
/*============================================================================= /*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2005-2006 Dan Marsden
Copyright (c) 2009-2010 Christopher Schmidt
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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_DETAIL_STRUCT_END_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_END_IMPL_HPP
namespace boost { namespace fusion #include <boost/fusion/iterator/basic_iterator.hpp>
#include <boost/type_traits/remove_const.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> template <typename Seq>
struct end_impl; struct apply
template <typename Struct>
struct struct_size;
template <>
struct end_impl<struct_tag>
{ {
template <typename Sequence> typedef
struct apply basic_iterator<
{ struct_iterator_tag
typedef , random_access_traversal_tag
struct_iterator< , Seq
Sequence , struct_size<typename remove_const<Seq>::type>::value
, struct_size<Sequence>::value >
> type;
type;
static type static type
call(Sequence& v) call(Seq& seq)
{ {
return type(v); return type(seq,0);
} }
};
}; };
} };
}}
template <>
struct end_impl<assoc_struct_tag>
{
template <typename Seq>
struct apply
{
typedef
basic_iterator<
assoc_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 #endif

42
include/boost/fusion/adapted/struct/detail/extension.hpp Normal file
View File

@ -0,0 +1,42 @@
/*=============================================================================
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_DETAIL_STRUCT_EXTENSION_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_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 assoc_struct_iterator_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_assoc_key;
template<typename Seq>
struct struct_size;
}
}}
#endif

40
include/boost/fusion/adapted/struct/detail/has_key_impl.hpp
View File

@ -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

33
include/boost/fusion/adapted/struct/detail/is_sequence_impl.hpp
View File

@ -5,27 +5,30 @@
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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_DETAIL_STRUCT_IS_SEQUENCE_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_IS_SEQUENCE_IMPL_HPP
#include <boost/mpl/bool.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> template<typename Seq>
struct is_sequence_impl; struct apply
: mpl::true_
{};
};
template<> template <>
struct is_sequence_impl<struct_tag> struct is_sequence_impl<assoc_struct_tag>
{ : is_sequence_impl<struct_tag>
template<typename Sequence> {};
struct apply : mpl::true_ {}; }}}
};
}
}}
#endif #endif

34
include/boost/fusion/adapted/struct/detail/is_view_impl.hpp
View File

@ -5,28 +5,30 @@
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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_DETAIL_STRUCT_IS_VIEW_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_IS_VIEW_IMPL_HPP
#include <boost/mpl/bool.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> template<typename Seq>
struct is_view_impl; struct apply
: mpl::false_
{};
};
template<> template <>
struct is_view_impl<struct_tag> struct is_view_impl<assoc_struct_tag>
{ : is_view_impl<struct_tag>
template<typename T> {};
struct apply : mpl::false_ }}}
{};
};
}
}}
#endif #endif

34
include/boost/fusion/adapted/struct/detail/key_of_impl.hpp Normal file
View File

@ -0,0 +1,34 @@
/*=============================================================================
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_DETAIL_STRUCT_KEY_OF_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_KEY_OF_IMPL_HPP
#include <boost/type_traits/remove_const.hpp>
namespace boost { namespace fusion { namespace extension
{
template <typename>
struct key_of_impl;
template <>
struct key_of_impl<assoc_struct_iterator_tag>
{
template <typename It>
struct apply
{
typedef typename
extension::struct_assoc_key<
typename remove_const<typename It::seq_type>::type
, It::index::value
>::type
type;
};
};
}}}
#endif

60
include/boost/fusion/adapted/struct/detail/proxy_type.hpp Normal file
View File

@ -0,0 +1,60 @@
/*=============================================================================
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_DETAIL_STRUCT_PROXY_TYPE_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_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

43
include/boost/fusion/adapted/struct/detail/size_impl.hpp
View File

@ -5,33 +5,30 @@
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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_DETAIL_STRUCT_SIZE_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_SIZE_IMPL_HPP
namespace boost { namespace fusion #include <boost/type_traits/remove_const.hpp>
namespace boost { namespace fusion { namespace extension
{ {
namespace extension template<typename>
struct size_impl;
template <>
struct size_impl<struct_tag>
{ {
template <typename Struct> template <typename Seq>
struct struct_size; struct apply
} : struct_size<typename remove_const<Seq>::type>
{};
};
struct struct_tag; template <>
struct size_impl<assoc_struct_tag>
namespace extension : size_impl<struct_tag>
{ {};
template<typename T> }}}
struct size_impl;
template <>
struct size_impl<struct_tag>
{
template <typename Sequence>
struct apply : extension::struct_size<Sequence> {};
};
}
}}
#endif #endif

51
include/boost/fusion/adapted/struct/detail/value_at_impl.hpp
View File

@ -5,43 +5,30 @@
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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> #ifndef BOOST_FUSION_ADAPTED_DETAIL_STRUCT_VALUE_AT_IMPL_HPP
#include <boost/static_assert.hpp> #define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_VALUE_AT_IMPL_HPP
namespace boost { namespace fusion #include <boost/type_traits/remove_const.hpp>
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> template <typename Seq, typename N>
struct value_at_impl; struct apply
: struct_member<typename remove_const<Seq>::type, N::value>
{};
};
template <typename Struct, int N> template <>
struct struct_member; struct value_at_impl<assoc_struct_tag>
: value_at_impl<struct_tag>
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;
};
};
}
}}
#endif #endif

39
include/boost/fusion/adapted/struct/detail/value_at_key_impl.hpp
View File

@ -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

22
include/boost/fusion/adapted/struct/detail/value_of_data_impl.hpp Normal file
View File

@ -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_DETAIL_STRUCT_VALUE_OF_DATA_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_VALUE_OF_DATA_IMPL_HPP
namespace boost { namespace fusion { namespace extension
{
template <typename>
struct value_of_data_impl;
template <>
struct value_of_data_impl<assoc_struct_iterator_tag>
: value_of_impl<assoc_struct_iterator_tag>
{};
}}}
#endif

39
include/boost/fusion/adapted/struct/detail/value_of_impl.hpp Normal file
View File

@ -0,0 +1,39 @@
/*=============================================================================
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_DETAIL_STRUCT_VALUE_OF_IMPL_HPP
#define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_VALUE_OF_IMPL_HPP
#include <boost/type_traits/remove_const.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
{
typedef typename
extension::struct_member<
typename remove_const<typename It::seq_type>::type
, It::index::value
>::type
type;
};
};
template <>
struct value_of_impl<assoc_struct_iterator_tag>
: value_of_impl<struct_iterator_tag>
{};
}}}
#endif

73
include/boost/fusion/adapted/struct/extension.hpp
View File

@ -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

107
include/boost/fusion/adapted/struct/struct_iterator.hpp
View File

@ -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

13
include/boost/fusion/include/adapt_assoc_class.hpp Normal file
View File

@ -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

13
include/boost/fusion/include/adapt_assoc_class_named.hpp Normal file
View File

@ -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

13
include/boost/fusion/include/adapt_assoc_struct.hpp Normal file
View File

@ -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

13
include/boost/fusion/include/adapt_assoc_struct_named.hpp Normal file
View File

@ -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

7
include/boost/fusion/include/adapt_class.hpp
View File

@ -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 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) 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/adapted/class/adapt_class.hpp>

13
include/boost/fusion/include/adapt_class_named.hpp Normal file
View File

@ -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

5
include/boost/fusion/include/adapt_struct.hpp
View File

@ -4,8 +4,9 @@
Distributed under the Boost Software License, Version 1.0. (See accompanying 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) 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/adapted/struct/adapt_struct.hpp>

7
include/boost/fusion/include/adapt_struct_named.hpp
View File

@ -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 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) 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/adapted/struct/adapt_struct_named.hpp>

5
include/boost/fusion/support/is_sequence.hpp
View File

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

15
test/Jamfile
View File

@ -108,12 +108,19 @@ import testing ;
[ run sequence/zip_view_ignore.cpp : : : : ] [ run sequence/zip_view_ignore.cpp : : : : ]
[ run sequence/repetitive_view.cpp : : : : ] [ run sequence/repetitive_view.cpp : : : : ]
[ run sequence/deduce_sequence.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_assoc_struct.cpp : : : : ]
[ run sequence/adapt_struct_named.cpp : : : : ] [ run sequence/adapt_assoc_tpl_class.cpp : : : : ]
[ run sequence/adapt_class.cpp : : : : ] [ run sequence/adapt_assoc_tpl_struct.cpp : : : : ]
[ run sequence/adapt_class_named.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.cpp : : : : ]
[ run functional/fused_function_object.cpp : : : : ] [ run functional/fused_function_object.cpp : : : : ]
[ run functional/fused_procedure.cpp : : : : ] [ run functional/fused_procedure.cpp : : : : ]

136
test/sequence/adapt_assoc_class.cpp Normal file
View File

@ -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();
}

142
test/sequence/adapt_assoc_class_named.cpp Normal file
View File

@ -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();
}

121
test/sequence/adapt_assoc_struct_named.cpp Normal file
View File

@ -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();
}

140
test/sequence/adapt_assoc_tpl_class.cpp Normal file
View File

@ -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();
}

133
test/sequence/adapt_assoc_tpl_struct.cpp Normal file
View File

@ -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();
}

133
test/sequence/adapt_tpl_class.cpp Normal file
View File

@ -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();
}

122
test/sequence/adapt_tpl_struct.cpp Normal file
View File

@ -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();
}