?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/proto.zip
???????
PK �J�[X�6�x, x, repeat.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file repeat.hpp /// Contains macros to ease the generation of repetitious code constructs // // Copyright 2008 Eric Niebler. 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_PROTO_REPEAT_HPP_EAN_11_24_2008 #define BOOST_PROTO_REPEAT_HPP_EAN_11_24_2008 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/iteration/local.hpp> #include <boost/preprocessor/tuple/elem.hpp> #include <boost/proto/proto_fwd.hpp> // for BOOST_PROTO_MAX_ARITY //////////////////////////////////////////// /// INTERNAL ONLY #define BOOST_PROTO_ref_a_aux(Z, N, DATA)\ boost::ref(BOOST_PP_CAT(proto_a, N)) /// \brief Generates a sequence like <tt>typename A0, typename A1, ...</tt> /// #define BOOST_PROTO_typename_A(N)\ BOOST_PP_ENUM_PARAMS(N, typename proto_A) /// \brief Generates a sequence like <tt>A0 const &, A1 const &, ...</tt> /// #define BOOST_PROTO_A_const_ref(N)\ BOOST_PP_ENUM_BINARY_PARAMS(N, proto_A, const & BOOST_PP_INTERCEPT) /// \brief Generates a sequence like <tt>A0 &, A1 &, ...</tt> /// #define BOOST_PROTO_A_ref(N)\ BOOST_PP_ENUM_BINARY_PARAMS(N, proto_A, & BOOST_PP_INTERCEPT) /// \brief Generates a sequence like <tt>A0, A1, ...</tt> /// #define BOOST_PROTO_A(N)\ BOOST_PP_ENUM_PARAMS(N, proto_A) /// \brief Generates a sequence like <tt>A0 const, A1 const, ...</tt> /// #define BOOST_PROTO_A_const(N)\ BOOST_PP_ENUM_PARAMS(N, const proto_A) /// \brief Generates a sequence like <tt>A0 const &a0, A1 const &a0, ...</tt> /// #define BOOST_PROTO_A_const_ref_a(N)\ BOOST_PP_ENUM_BINARY_PARAMS(N, proto_A, const &proto_a) /// \brief Generates a sequence like <tt>A0 &a0, A1 &a0, ...</tt> /// #define BOOST_PROTO_A_ref_a(N)\ BOOST_PP_ENUM_BINARY_PARAMS(N, proto_A, &proto_a) /// \brief Generates a sequence like <tt>boost::ref(a0), boost::ref(a1), ...</tt> /// #define BOOST_PROTO_ref_a(N)\ BOOST_PP_ENUM(N, BOOST_PROTO_ref_a_aux, ~) /// \brief Generates a sequence like <tt>a0, a1, ...</tt> /// #define BOOST_PROTO_a(N)\ BOOST_PP_ENUM_PARAMS(N, proto_a) //////////////////////////////////////////// /// INTERNAL ONLY #define BOOST_PROTO_invoke(Z, N, DATA)\ BOOST_PP_TUPLE_ELEM(5,0,DATA)(N, BOOST_PP_TUPLE_ELEM(5,1,DATA), BOOST_PP_TUPLE_ELEM(5,2,DATA), BOOST_PP_TUPLE_ELEM(5,3,DATA), BOOST_PP_TUPLE_ELEM(5,4,DATA)) /// \brief Repeatedly invoke the specified macro. /// /// BOOST_PROTO_REPEAT_FROM_TO_EX() is used generate the kind of repetitive code that is typical /// of EDSLs built with Proto. BOOST_PROTO_REPEAT_FROM_TO_EX(FROM, TO, MACRO, typename_A, A, A_a, a) is equivalent to: /// /// \code /// MACRO(FROM, typename_A, A, A_a, a) /// MACRO(FROM+1, typename_A, A, A_a, a) /// ... /// MACRO(TO-1, typename_A, A, A_a, a) /// \endcode #define BOOST_PROTO_REPEAT_FROM_TO_EX(FROM, TO, MACRO, typename_A, A, A_a, a)\ BOOST_PP_REPEAT_FROM_TO(FROM, TO, BOOST_PROTO_invoke, (MACRO, typename_A, A, A_a, a)) /// \brief Repeatedly invoke the specified macro. /// /// BOOST_PROTO_REPEAT_FROM_TO() is used generate the kind of repetitive code that is typical /// of EDSLs built with Proto. BOOST_PROTO_REPEAT_FROM_TO(FROM, TO, MACRO) is equivalent to: /// /// \code /// MACRO(FROM, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) /// MACRO(FROM+1, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) /// ... /// MACRO(TO-1, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) /// \endcode /// /// Example: /// /** \code // Generate BOOST_PROTO_MAX_ARITY-1 overloads of the // following construct() function template. #define M0(N, typename_A, A_const_ref, A_const_ref_a, ref_a) \ template<typename T, typename_A(N)> \ typename proto::result_of::make_expr< \ proto::tag::function \ , construct_helper<T> \ , A_const_ref(N) \ >::type const \ construct(A_const_ref_a(N)) \ { \ return proto::make_expr< \ proto::tag::function \ >( \ construct_helper<T>() \ , ref_a(N) \ ); \ } BOOST_PROTO_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, M0) #undef M0 \endcode **/ /// The above invocation of BOOST_PROTO_REPEAT_FROM_TO() will generate /// the following code: /// /// \code /// template<typename T, typename A0> /// typename proto::result_of::make_expr< /// proto::tag::function /// , construct_helper<T> /// , A0 const & /// >::type const /// construct(A0 const & a0) /// { /// return proto::make_expr< /// proto::tag::function /// >( /// construct_helper<T>() /// , boost::ref(a0) /// ); /// } /// /// template<typename T, typename A0, typename A1> /// typename proto::result_of::make_expr< /// proto::tag::function /// , construct_helper<T> /// , A0 const & /// , A1 const & /// >::type const /// construct(A0 const & a0, A1 const & a1) /// { /// return proto::make_expr< /// proto::tag::function /// >( /// construct_helper<T>() /// , boost::ref(a0) /// , boost::ref(a1) /// ); /// } /// /// // ... and so on, up to BOOST_PROTO_MAX_ARITY-1 arguments ... /// \endcode #define BOOST_PROTO_REPEAT_FROM_TO(FROM, TO, MACRO)\ BOOST_PROTO_REPEAT_FROM_TO_EX(FROM, TO, MACRO, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) /// \brief Repeatedly invoke the specified macro. /// /// BOOST_PROTO_REPEAT_EX() is used generate the kind of repetitive code that is typical /// of EDSLs built with Proto. BOOST_PROTO_REPEAT_EX(MACRO, typename_A, A, A_a, a) is equivalent to: /// /// \code /// MACRO(1, typename_A, A, A_a, a) /// MACRO(2, typename_A, A, A_a, a) /// ... /// MACRO(BOOST_PROTO_MAX_ARITY, typename_A, A, A_a, a) /// \endcode #define BOOST_PROTO_REPEAT_EX(MACRO, typename_A, A, A_a, a)\ BOOST_PROTO_REPEAT_FROM_TO_EX(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), MACRO, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) /// \brief Repeatedly invoke the specified macro. /// /// BOOST_PROTO_REPEAT() is used generate the kind of repetitive code that is typical /// of EDSLs built with Proto. BOOST_PROTO_REPEAT(MACRO) is equivalent to: /// /// \code /// MACRO(1, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) /// MACRO(2, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) /// ... /// MACRO(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) /// \endcode #define BOOST_PROTO_REPEAT(MACRO)\ BOOST_PROTO_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), MACRO) /// \brief Repeatedly invoke the specified macro. /// /// BOOST_PROTO_LOCAL_ITERATE() is used generate the kind of repetitive code that is typical /// of EDSLs built with Proto. This macro causes the user-defined macro BOOST_PROTO_LOCAL_MACRO to /// be expanded with values in the range specified by BOOST_PROTO_LOCAL_LIMITS. /// /// Usage: /// /// \code /// #include BOOST_PROTO_LOCAL_ITERATE() /// \endcode /// /// Example: /// /** \code // Generate BOOST_PROTO_MAX_ARITY-1 overloads of the // following construct() function template. #define BOOST_PROTO_LOCAL_MACRO(N, typename_A, A_const_ref, \ A_const_ref_a, ref_a) \ template<typename T, typename_A(N)> \ typename proto::result_of::make_expr< \ proto::tag::function \ , construct_helper<T> \ , A_const_ref(N) \ >::type const \ construct(A_const_ref_a(N)) \ { \ return proto::make_expr< \ proto::tag::function \ >( \ construct_helper<T>() \ , ref_a(N) \ ); \ } #define BOOST_PROTO_LOCAL_LIMITS (1, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY)) #include BOOST_PROTO_LOCAL_ITERATE() \endcode **/ /// The above inclusion of BOOST_PROTO_LOCAL_ITERATE() will generate /// the following code: /// /// \code /// template<typename T, typename A0> /// typename proto::result_of::make_expr< /// proto::tag::function /// , construct_helper<T> /// , A0 const & /// >::type const /// construct(A0 const & a0) /// { /// return proto::make_expr< /// proto::tag::function /// >( /// construct_helper<T>() /// , boost::ref(a0) /// ); /// } /// /// template<typename T, typename A0, typename A1> /// typename proto::result_of::make_expr< /// proto::tag::function /// , construct_helper<T> /// , A0 const & /// , A1 const & /// >::type const /// construct(A0 const & a0, A1 const & a1) /// { /// return proto::make_expr< /// proto::tag::function /// >( /// construct_helper<T>() /// , boost::ref(a0) /// , boost::ref(a1) /// ); /// } /// /// // ... and so on, up to BOOST_PROTO_MAX_ARITY-1 arguments ... /// \endcode /// /// If BOOST_PROTO_LOCAL_LIMITS is not defined by the user, it defaults /// to (1, BOOST_PROTO_MAX_ARITY) /// /// At each iteration, BOOST_PROTO_LOCAL_MACRO is invoked with the current /// iteration number and the following 4 macro parameters: /// /// \li BOOST_PROTO_LOCAL_typename_A /// \li BOOST_PROTO_LOCAL_A /// \li BOOST_PROTO_LOCAL_A_a /// \li BOOST_PROTO_LOCAL_a /// /// If these macros are not defined by the user, they default respectively to: /// /// \li BOOST_PROTO_typename_A /// \li BOOST_PROTO_A_const_ref /// \li BOOST_PROTO_A_const_ref_a /// \li BOOST_PROTO_ref_a /// /// After including BOOST_PROTO_LOCAL_ITERATE(), the following macros are /// automatically undefined: /// /// \li BOOST_PROTO_LOCAL_MACRO /// \li BOOST_PROTO_LOCAL_LIMITS /// \li BOOST_PROTO_LOCAL_typename_A /// \li BOOST_PROTO_LOCAL_A /// \li BOOST_PROTO_LOCAL_A_a /// \li BOOST_PROTO_LOCAL_a #define BOOST_PROTO_LOCAL_ITERATE() <boost/proto/detail/local.hpp> #endif PK �J�[�W��� � proto_typeof.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file proto_typeof.hpp /// Type registrations so that proto expression templates can be used together /// with the Boost.Typeof library. // // Copyright 2008 Eric Niebler. 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_XPRESSIVE_PROTO_PROTO_TYPEOF_H #define BOOST_XPRESSIVE_PROTO_PROTO_TYPEOF_H #include <boost/config.hpp> #include <boost/typeof/typeof.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/deep_copy.hpp> #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::terminal) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::unary_plus) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::negate) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::dereference) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::complement) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::address_of) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::logical_not) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::pre_inc) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::pre_dec) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::post_inc) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::post_dec) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::shift_left) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::shift_right) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::multiplies) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::divides) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::modulus) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::plus) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::minus) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::less) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::greater) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::less_equal) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::greater_equal) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::equal_to) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::not_equal_to) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::logical_or) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::logical_and) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_and) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_or) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_xor) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::comma) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::mem_ptr) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::assign) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::shift_left_assign) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::shift_right_assign) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::multiplies_assign) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::divides_assign) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::modulus_assign) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::plus_assign) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::minus_assign) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_and_assign) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_or_assign) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_xor_assign) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::subscript) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::member) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::if_else_) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::function) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::exprns_::is_proto_expr) BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::exprns_::expr, (typename)(typename)(long)) BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::exprns_::basic_expr, (typename)(typename)(long)) BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::utility::literal, (typename)(typename)) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::detail::not_a_generator) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::detail::not_a_grammar) BOOST_TYPEOF_REGISTER_TYPE(boost::proto::detail::not_a_domain) BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::domain, 3) BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::term, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list1, 1) BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list2, 2) // can't use PP metaprogramming here because all typeof registrations // must be on separate lines. #if BOOST_PROTO_MAX_ARITY >= 3 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list3, 3) #endif #if BOOST_PROTO_MAX_ARITY >= 4 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list4, 4) #endif #if BOOST_PROTO_MAX_ARITY >= 5 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list5, 5) #endif #if BOOST_PROTO_MAX_ARITY >= 6 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list6, 6) #endif #if BOOST_PROTO_MAX_ARITY >= 7 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list7, 7) #endif #if BOOST_PROTO_MAX_ARITY >= 8 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list8, 8) #endif #if BOOST_PROTO_MAX_ARITY >= 9 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list9, 9) #endif #if BOOST_PROTO_MAX_ARITY >= 10 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list10, 10) #endif #if BOOST_PROTO_MAX_ARITY >= 11 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list11, 11) #endif #if BOOST_PROTO_MAX_ARITY >= 12 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list12, 12) #endif #if BOOST_PROTO_MAX_ARITY >= 13 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list13, 13) #endif #if BOOST_PROTO_MAX_ARITY >= 14 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list14, 14) #endif #if BOOST_PROTO_MAX_ARITY >= 15 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list15, 15) #endif #if BOOST_PROTO_MAX_ARITY >= 16 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list16, 16) #endif #if BOOST_PROTO_MAX_ARITY >= 17 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list17, 17) #endif #if BOOST_PROTO_MAX_ARITY >= 18 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list18, 18) #endif #if BOOST_PROTO_MAX_ARITY >= 19 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list19, 19) #endif #if BOOST_PROTO_MAX_ARITY >= 20 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::list20, 20) #endif #define BOOST_PROTO_AUTO(Var, Expr) BOOST_AUTO(Var, boost::proto::deep_copy(Expr)) #define BOOST_PROTO_AUTO_TPL(Var, Expr) BOOST_AUTO_TPL(Var, boost::proto::deep_copy(Expr)) #endif PK �J�[��� core.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file core.hpp /// Includes the core of Proto. Not included are the contexts, transforms and /// debugging utilities. // // Copyright 2008 Eric Niebler. 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_PROTO_CORE_HPP_EAN_04_01_2005 #define BOOST_PROTO_CORE_HPP_EAN_04_01_2005 #include <boost/proto/proto_fwd.hpp> #include <boost/proto/args.hpp> #include <boost/proto/tags.hpp> #include <boost/proto/eval.hpp> #include <boost/proto/expr.hpp> #include <boost/proto/repeat.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/domain.hpp> #include <boost/proto/fusion.hpp> #include <boost/proto/matches.hpp> #include <boost/proto/extends.hpp> #include <boost/proto/literal.hpp> #include <boost/proto/generate.hpp> #include <boost/proto/operators.hpp> #include <boost/proto/deep_copy.hpp> #include <boost/proto/make_expr.hpp> #endif PK �J�[��V}7� 7� extends.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file extends.hpp /// Macros and a base class for defining end-user expression types // // Copyright 2008 Eric Niebler. 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_PROTO_EXTENDS_HPP_EAN_11_1_2006 #define BOOST_PROTO_EXTENDS_HPP_EAN_11_1_2006 #include <cstddef> // for offsetof #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/preprocessor/facilities/empty.hpp> #include <boost/preprocessor/tuple/elem.hpp> #include <boost/preprocessor/control/if.hpp> #include <boost/preprocessor/arithmetic/inc.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/iteration/local.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> #include <boost/preprocessor/seq/for_each.hpp> #include <boost/utility/addressof.hpp> #include <boost/utility/result_of.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/expr.hpp> #include <boost/proto/args.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/generate.hpp> #include <boost/proto/detail/remove_typename.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { #ifdef __GNUC__ /// INTERNAL ONLY /// # define BOOST_PROTO_ADDROF(x) ((char const volatile*)boost::addressof(x)) /// INTERNAL ONLY /// # define BOOST_PROTO_OFFSETOF(s,m) (BOOST_PROTO_ADDROF((((s *)this)->m)) - BOOST_PROTO_ADDROF(*((s *)this))) #else /// INTERNAL ONLY /// # define BOOST_PROTO_OFFSETOF offsetof #endif /// INTERNAL ONLY /// #define BOOST_PROTO_CONST() const /// INTERNAL ONLY /// #define BOOST_PROTO_TYPENAME() typename /// INTERNAL ONLY /// #define BOOST_PROTO_TEMPLATE_YES_(Z, N) template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)> /// INTERNAL ONLY /// #define BOOST_PROTO_TEMPLATE_NO_(Z, N) /// INTERNAL ONLY /// #define BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, Const) \ BOOST_PP_IF(N, BOOST_PROTO_TEMPLATE_YES_, BOOST_PROTO_TEMPLATE_NO_)(Z, N) \ BOOST_PROTO_PUSH_WARNINGS \ BOOST_PROTO_DISABLE_MSVC_C4180 \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename BOOST_PROTO_RESULT_OF< \ proto_generator( \ typename boost::proto::result_of::BOOST_PP_CAT(funop, N)< \ proto_derived_expr Const() \ , proto_domain \ BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A) \ >::type \ ) \ >::type const \ operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) Const() \ { \ typedef boost::proto::result_of::BOOST_PP_CAT(funop, N)< \ proto_derived_expr Const() \ , proto_domain \ BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A) \ > funop; \ return proto_generator()( \ funop::call( \ *static_cast<proto_derived_expr Const() *>(this) \ BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, a) \ ) \ ); \ } \ BOOST_PROTO_POP_WARNINGS \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(Const) \ template<typename... A> \ BOOST_PROTO_PUSH_WARNINGS \ BOOST_PROTO_DISABLE_MSVC_C4180 \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename BOOST_PROTO_RESULT_OF< \ proto_generator( \ typename boost::proto::result_of::funop< \ proto_derived_expr Const()(A const &...) \ , proto_derived_expr \ , proto_domain \ >::type \ ) \ >::type const \ operator ()(A const &...a) Const() \ { \ typedef boost::proto::result_of::funop< \ proto_derived_expr Const()(A const &...) \ , proto_derived_expr \ , proto_domain \ > funop; \ return proto_generator()( \ funop::call( \ *static_cast<proto_derived_expr Const() *>(this) \ , a... \ ) \ ); \ } \ BOOST_PROTO_POP_WARNINGS \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA) \ BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, BOOST_PROTO_CONST) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA) \ BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, BOOST_PP_EMPTY) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_DEFINE_FUN_OP(Z, N, DATA) \ BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA) \ BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_EXTENDS_CHILD(Z, N, DATA) \ typedef \ typename proto_base_expr::BOOST_PP_CAT(proto_child, N) \ BOOST_PP_CAT(proto_child, N); \ /**/ #define BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain) \ Expr proto_expr_; \ \ typedef Expr proto_base_expr_; /**< INTERNAL ONLY */ \ typedef typename proto_base_expr_::proto_base_expr proto_base_expr; \ typedef BOOST_PROTO_REMOVE_TYPENAME(Domain) proto_domain; \ typedef Derived proto_derived_expr; \ typedef Domain::proto_generator proto_generator; \ typedef typename proto_base_expr::proto_tag proto_tag; \ typedef typename proto_base_expr::proto_args proto_args; \ typedef typename proto_base_expr::proto_arity proto_arity; \ typedef typename proto_base_expr::proto_grammar proto_grammar; \ typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_; \ typedef void proto_is_expr_; /**< INTERNAL ONLY */ \ static const long proto_arity_c = proto_base_expr::proto_arity_c; \ typedef boost::proto::tag::proto_expr<proto_tag, proto_domain> fusion_tag; \ BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_CHILD, ~) \ \ BOOST_PROTO_PUSH_WARNINGS \ \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ static proto_derived_expr const make(Expr const &e) \ { \ proto_derived_expr that = {e}; \ return that; \ } \ \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ proto_base_expr &proto_base() \ { \ return this->proto_expr_.proto_base(); \ } \ \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ proto_base_expr const &proto_base() const \ { \ return this->proto_expr_.proto_base(); \ } \ \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ operator proto_address_of_hack_type_() const \ { \ return boost::addressof(this->proto_base().child0); \ } \ \ BOOST_PROTO_POP_WARNINGS \ /**/ #define BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) \ BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain) \ typedef void proto_is_aggregate_; \ /**< INTERNAL ONLY */ #define BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, Const, Typename) \ BOOST_PROTO_PUSH_WARNINGS \ BOOST_PROTO_DISABLE_MSVC_C4522 \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ Typename() BOOST_PROTO_RESULT_OF< \ Typename() This::proto_generator( \ Typename() boost::proto::base_expr< \ Typename() This::proto_domain \ , boost::proto::tag::assign \ , boost::proto::list2< \ This & \ , This Const() & \ > \ >::type \ ) \ >::type const \ operator =(This Const() &a) \ { \ typedef \ Typename() boost::proto::base_expr< \ Typename() This::proto_domain \ , boost::proto::tag::assign \ , boost::proto::list2< \ This & \ , This Const() & \ > \ >::type \ that_type; \ that_type const that = { \ *this \ , a \ }; \ return Typename() This::proto_generator()(that); \ } \ BOOST_PROTO_POP_WARNINGS \ /**/ // MSVC 8.0 and higher seem to need copy-assignment operator to be overloaded on *both* // const and non-const rhs arguments. #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) && (BOOST_MSVC > 1310) #define BOOST_PROTO_EXTENDS_COPY_ASSIGN_(This, Typename) \ BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PP_EMPTY, Typename) \ BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PROTO_CONST, Typename) \ /**/ #else #define BOOST_PROTO_EXTENDS_COPY_ASSIGN_(This, Typename) \ BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PROTO_CONST, Typename) \ /**/ #endif /// INTERNAL ONLY /// #define BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(ThisConst, ThatConst) \ template<typename A> \ BOOST_PROTO_PUSH_WARNINGS \ BOOST_PROTO_DISABLE_MSVC_C4180 \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename BOOST_PROTO_RESULT_OF< \ proto_generator( \ typename boost::proto::base_expr< \ proto_domain \ , boost::proto::tag::assign \ , boost::proto::list2< \ proto_derived_expr ThisConst() & \ , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \ > \ >::type \ ) \ >::type const \ operator =(A ThatConst() &a) ThisConst() \ { \ typedef \ typename boost::proto::base_expr< \ proto_domain \ , boost::proto::tag::assign \ , boost::proto::list2< \ proto_derived_expr ThisConst() & \ , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \ > \ >::type \ that_type; \ that_type const that = { \ *static_cast<proto_derived_expr ThisConst() *>(this) \ , boost::proto::as_child<proto_domain>(a) \ }; \ return proto_generator()(that); \ } \ BOOST_PROTO_POP_WARNINGS \ /**/ #define BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \ BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY) \ BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST) \ /**/ #define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \ BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY) \ BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST) \ /**/ #define BOOST_PROTO_EXTENDS_ASSIGN_() \ BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \ BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \ /**/ #define BOOST_PROTO_EXTENDS_ASSIGN_CONST() \ BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \ BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \ /**/ #define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST() \ BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \ BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \ /**/ #define BOOST_PROTO_EXTENDS_ASSIGN() \ BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \ BOOST_PROTO_EXTENDS_ASSIGN_() \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(ThisConst, ThatConst) \ template<typename A> \ BOOST_PROTO_PUSH_WARNINGS \ BOOST_PROTO_DISABLE_MSVC_C4180 \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename BOOST_PROTO_RESULT_OF< \ proto_generator( \ typename boost::proto::base_expr< \ proto_domain \ , boost::proto::tag::subscript \ , boost::proto::list2< \ proto_derived_expr ThisConst() & \ , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \ > \ >::type \ ) \ >::type const \ operator [](A ThatConst() &a) ThisConst() \ { \ typedef \ typename boost::proto::base_expr< \ proto_domain \ , boost::proto::tag::subscript \ , boost::proto::list2< \ proto_derived_expr ThisConst() & \ , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \ > \ >::type \ that_type; \ that_type const that = { \ *static_cast<proto_derived_expr ThisConst() *>(this) \ , boost::proto::as_child<proto_domain>(a) \ }; \ return proto_generator()(that); \ } \ BOOST_PROTO_POP_WARNINGS \ /**/ #define BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() \ BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY) \ BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST) \ /**/ #define BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST() \ BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY) \ BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST) \ /**/ #define BOOST_PROTO_EXTENDS_SUBSCRIPT() \ BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() \ BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST() \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_EXTENDS_FUNCTION_() \ template<typename Sig> \ struct result \ { \ typedef \ typename BOOST_PROTO_RESULT_OF< \ proto_generator( \ typename boost::proto::result_of::funop< \ Sig \ , proto_derived_expr \ , proto_domain \ >::type \ ) \ >::type const \ type; \ }; \ /**/ #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES #define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \ BOOST_PROTO_EXTENDS_FUNCTION_() \ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) \ /**/ #define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \ BOOST_PROTO_EXTENDS_FUNCTION_() \ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) \ /**/ #define BOOST_PROTO_EXTENDS_FUNCTION() \ BOOST_PROTO_EXTENDS_FUNCTION_() \ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) \ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) \ /**/ #else #define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \ BOOST_PROTO_EXTENDS_FUNCTION_() \ BOOST_PP_REPEAT_FROM_TO( \ 0 \ , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \ , BOOST_PROTO_DEFINE_FUN_OP_CONST \ , ~ \ ) \ /**/ #define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \ BOOST_PROTO_EXTENDS_FUNCTION_() \ BOOST_PP_REPEAT_FROM_TO( \ 0 \ , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \ , BOOST_PROTO_DEFINE_FUN_OP_NON_CONST \ , ~ \ ) \ /**/ #define BOOST_PROTO_EXTENDS_FUNCTION() \ BOOST_PROTO_EXTENDS_FUNCTION_() \ BOOST_PP_REPEAT_FROM_TO( \ 0 \ , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \ , BOOST_PROTO_DEFINE_FUN_OP \ , ~ \ ) \ /**/ #endif #define BOOST_PROTO_EXTENDS(Expr, Derived, Domain) \ BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) \ BOOST_PROTO_EXTENDS_ASSIGN() \ BOOST_PROTO_EXTENDS_SUBSCRIPT() \ BOOST_PROTO_EXTENDS_FUNCTION() \ /**/ #define BOOST_PROTO_EXTENDS_USING_ASSIGN(Derived) \ typedef typename Derived::proto_extends proto_extends; \ using proto_extends::operator =; \ BOOST_PROTO_EXTENDS_COPY_ASSIGN_(Derived, BOOST_PROTO_TYPENAME) \ /**/ #define BOOST_PROTO_EXTENDS_USING_ASSIGN_NON_DEPENDENT(Derived) \ typedef Derived::proto_extends proto_extends; \ using proto_extends::operator =; \ BOOST_PROTO_EXTENDS_COPY_ASSIGN_(Derived, BOOST_PP_EMPTY) \ /**/ namespace exprns_ { /// \brief Empty type to be used as a dummy template parameter of /// POD expression wrappers. It allows argument-dependent lookup /// to find Proto's operator overloads. /// /// \c proto::is_proto_expr allows argument-dependent lookup /// to find Proto's operator overloads. For example: /// /// \code /// template<typename T, typename Dummy = proto::is_proto_expr> /// struct my_terminal /// { /// BOOST_PROTO_BASIC_EXTENDS( /// typename proto::terminal<T>::type /// , my_terminal<T> /// , default_domain /// ) /// }; /// /// // ... /// my_terminal<int> _1, _2; /// _1 + _2; // OK, uses proto::operator+ /// \endcode /// /// Without the second \c Dummy template parameter, Proto's operator /// overloads would not be considered by name lookup. struct is_proto_expr {}; /// \brief extends\<\> class template for adding behaviors to a Proto expression template /// template< typename Expr , typename Derived , typename Domain // = proto::default_domain , long Arity // = Expr::proto_arity_c > struct extends { BOOST_FORCEINLINE extends() : proto_expr_() {} BOOST_FORCEINLINE extends(Expr const &expr_) : proto_expr_(expr_) {} typedef extends proto_extends; BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, typename Domain) BOOST_PROTO_EXTENDS_ASSIGN_CONST_() BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses // nested preprocessor loops, use file iteration here to generate // the operator() overloads, which is more efficient. #include <boost/proto/detail/extends_funop_const.hpp> }; /// \brief extends\<\> class template for adding behaviors to a Proto expression template /// template<typename Expr, typename Derived, typename Domain> struct extends<Expr, Derived, Domain, 0> { BOOST_FORCEINLINE extends() : proto_expr_() {} BOOST_FORCEINLINE extends(Expr const &expr_) : proto_expr_(expr_) {} typedef extends proto_extends; BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, typename Domain) BOOST_PROTO_EXTENDS_ASSIGN_() BOOST_PROTO_EXTENDS_SUBSCRIPT() // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses // nested preprocessor loops, use file iteration here to generate // the operator() overloads, which is more efficient. #include <boost/proto/detail/extends_funop.hpp> }; /// INTERNAL ONLY /// template<typename This, typename Fun, typename Domain> struct virtual_member { typedef Domain proto_domain; typedef typename Domain::proto_generator proto_generator; typedef virtual_member<This, Fun, Domain> proto_derived_expr; typedef tag::member proto_tag; typedef list2<This &, expr<tag::terminal, term<Fun> > const &> proto_args; typedef mpl::long_<2> proto_arity; typedef detail::not_a_valid_type proto_address_of_hack_type_; typedef void proto_is_expr_; /**< INTERNAL ONLY */ static const long proto_arity_c = 2; typedef boost::proto::tag::proto_expr<proto_tag, Domain> fusion_tag; typedef This &proto_child0; typedef expr<tag::terminal, term<Fun> > const &proto_child1; typedef expr<proto_tag, proto_args, proto_arity_c> proto_base_expr; typedef basic_expr<proto_tag, proto_args, proto_arity_c> proto_grammar; typedef void proto_is_aggregate_; /**< INTERNAL ONLY */ BOOST_PROTO_EXTENDS_ASSIGN_() BOOST_PROTO_EXTENDS_SUBSCRIPT() // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses // nested preprocessor loops, use file iteration here to generate // the operator() overloads, which is more efficient. #define BOOST_PROTO_NO_WAVE_OUTPUT #include <boost/proto/detail/extends_funop.hpp> #undef BOOST_PROTO_NO_WAVE_OUTPUT BOOST_FORCEINLINE proto_base_expr const proto_base() const { proto_base_expr that = {this->child0(), this->child1()}; return that; } BOOST_FORCEINLINE proto_child0 child0() const { using std::size_t; return *(This *)((char *)this - BOOST_PROTO_OFFSETOF(This, proto_member_union_start_)); } BOOST_FORCEINLINE proto_child1 child1() const { static expr<tag::terminal, term<Fun>, 0> const that = {Fun()}; return that; } }; /// INTERNAL ONLY /// #define BOOST_PROTO_EXTENDS_MEMBER_(R, DOMAIN, ELEM) \ boost::proto::exprns_::virtual_member< \ proto_derived_expr \ , BOOST_PP_TUPLE_ELEM(2, 0, ELEM) \ , DOMAIN \ > BOOST_PP_TUPLE_ELEM(2, 1, ELEM); \ /**/ /// \brief For declaring virtual data members in an extension class. /// #define BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, DOMAIN) \ union \ { \ char proto_member_union_start_; \ BOOST_PP_SEQ_FOR_EACH(BOOST_PROTO_EXTENDS_MEMBER_, DOMAIN, SEQ) \ }; \ /**/ /// \brief For declaring virtual data members in an extension class. /// #define BOOST_PROTO_EXTENDS_MEMBERS(SEQ) \ BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, proto_domain) \ /**/ } }} #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[Z!^x x tags.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file tags.hpp /// Contains the tags for all the overloadable operators in C++ // // Copyright 2008 Eric Niebler. 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_PROTO_TAGS_HPP_EAN_04_01_2005 #define BOOST_PROTO_TAGS_HPP_EAN_04_01_2005 #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace tagns_ { namespace tag { /// Tag type for terminals; aka, leaves in the expression tree. struct terminal {}; /// Tag type for the unary + operator. struct unary_plus {}; /// Tag type for the unary - operator. struct negate {}; /// Tag type for the unary * operator. struct dereference {}; /// Tag type for the unary ~ operator. struct complement {}; /// Tag type for the unary & operator. struct address_of {}; /// Tag type for the unary ! operator. struct logical_not {}; /// Tag type for the unary prefix ++ operator. struct pre_inc {}; /// Tag type for the unary prefix -- operator. struct pre_dec {}; /// Tag type for the unary postfix ++ operator. struct post_inc {}; /// Tag type for the unary postfix -- operator. struct post_dec {}; /// Tag type for the binary \<\< operator. struct shift_left {}; /// Tag type for the binary \>\> operator. struct shift_right {}; /// Tag type for the binary * operator. struct multiplies {}; /// Tag type for the binary / operator. struct divides {}; /// Tag type for the binary % operator. struct modulus {}; /// Tag type for the binary + operator. struct plus {}; /// Tag type for the binary - operator. struct minus {}; /// Tag type for the binary \< operator. struct less {}; /// Tag type for the binary \> operator. struct greater {}; /// Tag type for the binary \<= operator. struct less_equal {}; /// Tag type for the binary \>= operator. struct greater_equal {}; /// Tag type for the binary == operator. struct equal_to {}; /// Tag type for the binary != operator. struct not_equal_to {}; /// Tag type for the binary || operator. struct logical_or {}; /// Tag type for the binary && operator. struct logical_and {}; /// Tag type for the binary & operator. struct bitwise_and {}; /// Tag type for the binary | operator. struct bitwise_or {}; /// Tag type for the binary ^ operator. struct bitwise_xor {}; /// Tag type for the binary , operator. struct comma {}; /// Tag type for the binary ->* operator. struct mem_ptr {}; /// Tag type for the binary = operator. struct assign {}; /// Tag type for the binary \<\<= operator. struct shift_left_assign {}; /// Tag type for the binary \>\>= operator. struct shift_right_assign {}; /// Tag type for the binary *= operator. struct multiplies_assign {}; /// Tag type for the binary /= operator. struct divides_assign {}; /// Tag type for the binary %= operator. struct modulus_assign {}; /// Tag type for the binary += operator. struct plus_assign {}; /// Tag type for the binary -= operator. struct minus_assign {}; /// Tag type for the binary &= operator. struct bitwise_and_assign {}; /// Tag type for the binary |= operator. struct bitwise_or_assign {}; /// Tag type for the binary ^= operator. struct bitwise_xor_assign {}; /// Tag type for the binary subscript operator. struct subscript {}; /// Tag type for the binary virtual data members. struct member {}; /// Tag type for the ternary ?: conditional operator. struct if_else_ {}; /// Tag type for the n-ary function call operator. struct function {}; }}}} #endif PK �J�[�ʗ�@ @ functional.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file functional.hpp /// Proto callables for various things // // Copyright 2010 Eric Niebler. 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_PROTO_FUNCTIONAL_HPP_EAN_11_27_2010 #define BOOST_PROTO_FUNCTIONAL_HPP_EAN_11_27_2010 #include <boost/proto/functional/std.hpp> #include <boost/proto/functional/fusion.hpp> #include <boost/proto/functional/range.hpp> #endif PK �J�[���� � transform.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file transform.hpp /// Includes all the transforms in the transform/ sub-directory. // // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_HPP_EAN_06_23_2007 #define BOOST_PROTO_TRANSFORM_HPP_EAN_06_23_2007 #include <boost/proto/transform/arg.hpp> #include <boost/proto/transform/call.hpp> #include <boost/proto/transform/default.hpp> #include <boost/proto/transform/env.hpp> #include <boost/proto/transform/fold.hpp> #include <boost/proto/transform/fold_tree.hpp> #include <boost/proto/transform/integral_c.hpp> #include <boost/proto/transform/lazy.hpp> #include <boost/proto/transform/make.hpp> #include <boost/proto/transform/pass_through.hpp> #include <boost/proto/transform/when.hpp> #endif PK �J�[6�u�8 �8 generate.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file generate.hpp /// Contains definition of generate\<\> class template, which end users can /// specialize for generating domain-specific expression wrappers. // // Copyright 2008 Eric Niebler. 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_PROTO_GENERATE_HPP_EAN_02_13_2007 #define BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007 #include <boost/config.hpp> #include <boost/version.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/mpl/bool.hpp> #include <boost/utility/enable_if.hpp> #include <boost/utility/result_of.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/args.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { template<typename Expr> struct by_value_generator_; template<typename Tag, typename Arg> struct by_value_generator_<proto::expr<Tag, term<Arg>, 0> > { typedef proto::expr< Tag , term<typename detail::term_traits<Arg>::value_type> , 0 > type; BOOST_FORCEINLINE static type const call(proto::expr<Tag, term<Arg>, 0> const &e) { type that = {e.child0}; return that; } }; template<typename Tag, typename Arg> struct by_value_generator_<proto::basic_expr<Tag, term<Arg>, 0> > { typedef proto::basic_expr< Tag , term<typename detail::term_traits<Arg>::value_type> , 0 > type; BOOST_FORCEINLINE static type const call(proto::basic_expr<Tag, term<Arg>, 0> const &e) { type that = {e.child0}; return that; } }; // Include the other specializations of by_value_generator_ #include <boost/proto/detail/generate_by_value.hpp> } /// \brief Annotate a generator to indicate that it would /// prefer to be passed instances of \c proto::basic_expr\<\> rather /// than \c proto::expr\<\>. <tt>use_basic_expr\<Generator\></tt> is /// itself a generator. /// template<typename Generator> struct use_basic_expr : Generator { BOOST_PROTO_USE_BASIC_EXPR() }; /// \brief A simple generator that passes an expression /// through unchanged. /// /// Generators are intended for use as the first template parameter /// to the \c domain\<\> class template and control if and how /// expressions within that domain are to be customized. /// The \c default_generator makes no modifications to the expressions /// passed to it. struct default_generator { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Expr> struct result<This(Expr)> { typedef Expr type; }; /// \param expr A Proto expression /// \return expr template<typename Expr> BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(Expr, Expr const &) operator ()(Expr const &e) const { return e; } }; /// \brief A simple generator that passes an expression /// through unchanged and specifies a preference for /// \c proto::basic_expr\<\> over \c proto::expr\<\>. /// /// Generators are intended for use as the first template parameter /// to the \c domain\<\> class template and control if and how /// expressions within that domain are to be customized. /// The \c default_generator makes no modifications to the expressions /// passed to it. struct basic_default_generator : proto::use_basic_expr<default_generator> {}; /// \brief A generator that wraps expressions passed /// to it in the specified extension wrapper. /// /// Generators are intended for use as the first template parameter /// to the \c domain\<\> class template and control if and how /// expressions within that domain are to be customized. /// \c generator\<\> wraps each expression passed to it in /// the \c Extends\<\> wrapper. template<template<typename> class Extends> struct generator { BOOST_PROTO_CALLABLE() BOOST_PROTO_USE_BASIC_EXPR() template<typename Sig> struct result; template<typename This, typename Expr> struct result<This(Expr)> { typedef Extends<Expr> type; }; template<typename This, typename Expr> struct result<This(Expr &)> { typedef Extends<Expr> type; }; template<typename This, typename Expr> struct result<This(Expr const &)> { typedef Extends<Expr> type; }; /// \param expr A Proto expression /// \return Extends<Expr>(expr) template<typename Expr> BOOST_FORCEINLINE Extends<Expr> operator ()(Expr const &e) const { return Extends<Expr>(e); } }; /// \brief A generator that wraps expressions passed /// to it in the specified extension wrapper and uses /// aggregate initialization for the wrapper. /// /// Generators are intended for use as the first template parameter /// to the \c domain\<\> class template and control if and how /// expressions within that domain are to be customized. /// \c pod_generator\<\> wraps each expression passed to it in /// the \c Extends\<\> wrapper, and uses aggregate initialzation /// for the wrapped object. template<template<typename> class Extends> struct pod_generator { BOOST_PROTO_CALLABLE() BOOST_PROTO_USE_BASIC_EXPR() template<typename Sig> struct result; template<typename This, typename Expr> struct result<This(Expr)> { typedef Extends<Expr> type; }; template<typename This, typename Expr> struct result<This(Expr &)> { typedef Extends<Expr> type; }; template<typename This, typename Expr> struct result<This(Expr const &)> { typedef Extends<Expr> type; }; /// \param expr The expression to wrap /// \return <tt>Extends\<Expr\> that = {expr}; return that;</tt> template<typename Expr> BOOST_FORCEINLINE Extends<Expr> operator ()(Expr const &e) const { Extends<Expr> that = {e}; return that; } // Work-around for: // https://connect.microsoft.com/VisualStudio/feedback/details/765449/codegen-stack-corruption-using-runtime-checks-when-aggregate-initializing-struct #if BOOST_WORKAROUND(BOOST_MSVC, < 1800) template<typename Class, typename Member> BOOST_FORCEINLINE Extends<expr<tag::terminal, proto::term<Member Class::*> > > operator ()(expr<tag::terminal, proto::term<Member Class::*> > const &e) const { Extends<expr<tag::terminal, proto::term<Member Class::*> > > that; proto::value(that.proto_expr_) = proto::value(e); return that; } template<typename Class, typename Member> BOOST_FORCEINLINE Extends<basic_expr<tag::terminal, proto::term<Member Class::*> > > operator ()(basic_expr<tag::terminal, proto::term<Member Class::*> > const &e) const { Extends<basic_expr<tag::terminal, proto::term<Member Class::*> > > that; proto::value(that.proto_expr_) = proto::value(e); return that; } #endif }; /// \brief A generator that replaces child nodes held by /// reference with ones held by value. Use with /// \c compose_generators to forward that result to another /// generator. /// /// Generators are intended for use as the first template parameter /// to the \c domain\<\> class template and control if and how /// expressions within that domain are to be customized. /// \c by_value_generator ensures all child nodes are /// held by value. This generator is typically composed with a /// second generator for further processing, as /// <tt>compose_generators\<by_value_generator, MyGenerator\></tt>. struct by_value_generator { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Expr> struct result<This(Expr)> { typedef typename detail::by_value_generator_<Expr>::type type; }; template<typename This, typename Expr> struct result<This(Expr &)> { typedef typename detail::by_value_generator_<Expr>::type type; }; template<typename This, typename Expr> struct result<This(Expr const &)> { typedef typename detail::by_value_generator_<Expr>::type type; }; /// \param expr The expression to modify. /// \return <tt>deep_copy(expr)</tt> template<typename Expr> BOOST_FORCEINLINE typename result<by_value_generator(Expr)>::type operator ()(Expr const &e) const { return detail::by_value_generator_<Expr>::call(e); } }; /// \brief A composite generator that first applies one /// transform to an expression and then forwards the result /// on to another generator for further transformation. /// /// Generators are intended for use as the first template parameter /// to the \c domain\<\> class template and control if and how /// expressions within that domain are to be customized. /// \c compose_generators\<\> is a composite generator that first /// applies one transform to an expression and then forwards the /// result on to another generator for further transformation. template<typename First, typename Second> struct compose_generators { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Expr> struct result<This(Expr)> { typedef typename Second::template result< Second(typename First::template result<First(Expr)>::type) >::type type; }; template<typename This, typename Expr> struct result<This(Expr &)> { typedef typename Second::template result< Second(typename First::template result<First(Expr)>::type) >::type type; }; template<typename This, typename Expr> struct result<This(Expr const &)> { typedef typename Second::template result< Second(typename First::template result<First(Expr)>::type) >::type type; }; /// \param expr The expression to modify. /// \return Second()(First()(expr)) template<typename Expr> BOOST_FORCEINLINE typename result<compose_generators(Expr)>::type operator ()(Expr const &e) const { return Second()(First()(e)); } }; /// \brief Tests a generator to see whether it would prefer /// to be passed instances of \c proto::basic_expr\<\> rather than /// \c proto::expr\<\>. /// template<typename Generator, typename Void> struct wants_basic_expr : mpl::false_ {}; template<typename Generator> struct wants_basic_expr<Generator, typename Generator::proto_use_basic_expr_> : mpl::true_ {}; /// INTERNAL ONLY template<> struct is_callable<default_generator> : mpl::true_ {}; /// INTERNAL ONLY template<template<typename> class Extends> struct is_callable<generator<Extends> > : mpl::true_ {}; /// INTERNAL ONLY template<template<typename> class Extends> struct is_callable<pod_generator<Extends> > : mpl::true_ {}; /// INTERNAL ONLY template<> struct is_callable<by_value_generator> : mpl::true_ {}; /// INTERNAL ONLY template<typename First, typename Second> struct is_callable<compose_generators<First, Second> > : mpl::true_ {}; }} // Specializations of boost::result_of and boost::tr1_result_of to eliminate // some unnecessary template instantiations namespace boost { template<typename Expr> struct result_of<proto::default_domain(Expr)> { typedef Expr type; }; template<typename Expr> struct result_of<proto::basic_default_domain(Expr)> { typedef Expr type; }; template<typename Expr> struct result_of<proto::default_generator(Expr)> { typedef Expr type; }; template<typename Expr> struct result_of<proto::basic_default_generator(Expr)> { typedef Expr type; }; #if BOOST_VERSION >= 104400 template<typename Expr> struct tr1_result_of<proto::default_domain(Expr)> { typedef Expr type; }; template<typename Expr> struct tr1_result_of<proto::basic_default_domain(Expr)> { typedef Expr type; }; template<typename Expr> struct tr1_result_of<proto::default_generator(Expr)> { typedef Expr type; }; template<typename Expr> struct tr1_result_of<proto::basic_default_generator(Expr)> { typedef Expr type; }; #endif } #if defined(_MSC_VER) # pragma warning(pop) #endif #endif // BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007 PK �J�[B�6��r �r proto_fwd.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file proto_fwd.hpp /// Forward declarations of all of proto's public types and functions. // // Copyright 2008 Eric Niebler. 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_PROTO_FWD_HPP_EAN_04_01_2005 #define BOOST_PROTO_FWD_HPP_EAN_04_01_2005 #include <cstddef> #include <climits> #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/arithmetic/inc.hpp> #include <boost/preprocessor/punctuation/comma.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/ref.hpp> #include <boost/mpl/long.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/mpl/aux_/config/ttp.hpp> #include <boost/utility/result_of.hpp> #ifndef BOOST_PROTO_MAX_ARITY # define BOOST_PROTO_MAX_ARITY 10 #endif #ifndef BOOST_PROTO_MAX_LOGICAL_ARITY # define BOOST_PROTO_MAX_LOGICAL_ARITY 10 #endif #ifndef BOOST_PROTO_MAX_FUNCTION_CALL_ARITY # define BOOST_PROTO_MAX_FUNCTION_CALL_ARITY BOOST_PROTO_MAX_ARITY #endif #if BOOST_PROTO_MAX_ARITY < 3 # error BOOST_PROTO_MAX_ARITY must be at least 3 #endif #if BOOST_PROTO_MAX_FUNCTION_CALL_ARITY > BOOST_PROTO_MAX_ARITY # error BOOST_PROTO_MAX_FUNCTION_CALL_ARITY cannot be larger than BOOST_PROTO_MAX_ARITY #endif #ifndef BOOST_PROTO_DONT_USE_PREPROCESSED_FILES #if 10 < BOOST_PROTO_MAX_ARITY || \ 10 < BOOST_PROTO_MAX_LOGICAL_ARITY || \ 10 < BOOST_PROTO_MAX_FUNCTION_CALL_ARITY #define BOOST_PROTO_DONT_USE_PREPROCESSED_FILES #endif #endif #ifndef BOOST_PROTO_BROKEN_CONST_OVERLOADS # if BOOST_WORKAROUND(__GNUC__, == 3) \ || BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310)) # define BOOST_PROTO_BROKEN_CONST_OVERLOADS # endif #endif #ifndef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS # if BOOST_WORKAROUND(__GNUC__, == 3) \ || BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310)) # define BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS # endif #endif #ifdef BOOST_PROTO_BROKEN_CONST_OVERLOADS # include <boost/utility/enable_if.hpp> # include <boost/type_traits/is_const.hpp> # define BOOST_PROTO_DISABLE_IF_IS_CONST(T)\ , typename boost::disable_if_c<boost::is_const<T>::value, boost::proto::detail::undefined>::type * = 0 #else # define BOOST_PROTO_DISABLE_IF_IS_CONST(T) #endif #ifdef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS # include <boost/utility/enable_if.hpp> # include <boost/type_traits/is_function.hpp> # define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)\ , typename boost::disable_if_c<boost::is_function<T>::value, boost::proto::detail::undefined>::type * = 0 #else # define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T) #endif #ifndef BOOST_PROTO_BROKEN_PTS # if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) # define BOOST_PROTO_BROKEN_PTS # endif #endif #ifdef BOOST_NO_CXX11_DECLTYPE_N3276 # // Proto can only use the decltype-based result_of if N3276 has been # // implemented by the compiler. # // See http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2011/n3276.pdf # ifndef BOOST_PROTO_USE_NORMAL_RESULT_OF # define BOOST_PROTO_USE_NORMAL_RESULT_OF # endif #endif // Unless compiler support is there, use tr1_result_of instead of // result_of to avoid the problems addressed by N3276. #ifdef BOOST_PROTO_USE_NORMAL_RESULT_OF # define BOOST_PROTO_RESULT_OF boost::result_of #else # define BOOST_PROTO_RESULT_OF boost::tr1_result_of #endif // If we're using the decltype-based result_of, we need to be a bit // stricter about the return types of some functions. #if defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_PROTO_USE_NORMAL_RESULT_OF) # define BOOST_PROTO_STRICT_RESULT_OF # define BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(X, Y) X #else # define BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(X, Y) Y #endif #ifdef BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING # define BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING #endif #if defined(_MSC_VER) # define BOOST_PROTO_PUSH_WARNINGS __pragma(warning(push)) # define BOOST_PROTO_POP_WARNINGS __pragma(warning(pop)) # define BOOST_PROTO_DISABLE_MSVC_C4180 __pragma(warning(disable : 4180)) // qualifier applied to function type has no meaning; ignored # define BOOST_PROTO_DISABLE_MSVC_C4522 __pragma(warning(disable : 4522)) // 'class' : multiple assignment operators specified # define BOOST_PROTO_DISABLE_MSVC_C4714 __pragma(warning(disable : 4714)) // function 'xxx' marked as __forceinline not inlined #else # define BOOST_PROTO_PUSH_WARNINGS # define BOOST_PROTO_POP_WARNINGS # define BOOST_PROTO_DISABLE_MSVC_C4180 # define BOOST_PROTO_DISABLE_MSVC_C4522 # define BOOST_PROTO_DISABLE_MSVC_C4714 #endif namespace boost { namespace proto { namespace detail { typedef char yes_type; typedef char (&no_type)[2]; template<int N> struct sized_type { typedef char (&type)[N]; }; struct dont_care; struct undefined; // leave this undefined struct not_a_valid_type; struct private_type_ { private_type_ operator ,(int) const; }; template<typename T> struct uncvref { typedef T type; }; template<typename T> struct uncvref<T const> { typedef T type; }; template<typename T> struct uncvref<T &> { typedef T type; }; template<typename T> struct uncvref<T const &> { typedef T type; }; template<typename T, std::size_t N> struct uncvref<T const[N]> { typedef T type[N]; }; template<typename T, std::size_t N> struct uncvref<T (&)[N]> { typedef T type[N]; }; template<typename T, std::size_t N> struct uncvref<T const (&)[N]> { typedef T type[N]; }; struct ignore { ignore() {} template<typename T> ignore(T const &) {} }; /// INTERNAL ONLY /// #define BOOST_PROTO_UNCVREF(X) \ typename boost::proto::detail::uncvref<X>::type \ /**/ struct _default; struct not_a_domain; struct not_a_grammar; struct not_a_generator; template<typename T, typename Void = void> struct is_transform_; template<typename T, typename Void = void> struct is_aggregate_; template<typename Expr> struct flat_view; } typedef detail::ignore const ignore; namespace argsns_ { template<typename Arg0> struct term; #define M0(Z, N, DATA) \ template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename Arg)> struct BOOST_PP_CAT(list, N); \ /**/ BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M0, ~) #undef M0 } using namespace argsns_; /////////////////////////////////////////////////////////////////////////////// // Operator tags namespace tagns_ { namespace tag { struct terminal; struct unary_plus; struct negate; struct dereference; struct complement; struct address_of; struct logical_not; struct pre_inc; struct pre_dec; struct post_inc; struct post_dec; struct shift_left; struct shift_right; struct multiplies; struct divides; struct modulus; struct plus; struct minus; struct less; struct greater; struct less_equal; struct greater_equal; struct equal_to; struct not_equal_to; struct logical_or; struct logical_and; struct bitwise_and; struct bitwise_or; struct bitwise_xor; struct comma; struct mem_ptr; struct assign; struct shift_left_assign; struct shift_right_assign; struct multiplies_assign; struct divides_assign; struct modulus_assign; struct plus_assign; struct minus_assign; struct bitwise_and_assign; struct bitwise_or_assign; struct bitwise_xor_assign; struct subscript; struct member; struct if_else_; struct function; // Fusion tags template<typename Tag, typename Domain> struct proto_expr; template<typename Tag, typename Domain> struct proto_expr_iterator; template<typename Tag, typename Domain> struct proto_flat_view; } } using namespace tagns_; template<typename Expr> struct tag_of; //////////////////////////////////////////////////////////////////////////////////////////////// struct _; //////////////////////////////////////////////////////////////////////////////////////////////// struct default_generator; struct basic_default_generator; template<template<typename> class Extends> struct generator; template<template<typename> class Extends> struct pod_generator; struct by_value_generator; template<typename First, typename Second> struct compose_generators; template<typename Generator, typename Void = void> struct wants_basic_expr; template<typename Generator> struct use_basic_expr; //////////////////////////////////////////////////////////////////////////////////////////////// namespace domainns_ { typedef detail::not_a_domain no_super_domain; template< typename Generator = default_generator , typename Grammar = proto::_ , typename Super = no_super_domain > struct domain; struct default_domain; struct basic_default_domain; struct deduce_domain; template<typename Domain, typename Tag, typename Args, bool WantsBasicExpr = wants_basic_expr<typename Domain::proto_generator>::value> struct base_expr; } using namespace domainns_; //////////////////////////////////////////////////////////////////////////////////////////////// namespace exprns_ { template<typename Tag, typename Args, long Arity = Args::arity> struct basic_expr; template<typename Tag, typename Args, long Arity = Args::arity> struct expr; template< typename Expr , typename Derived , typename Domain = default_domain , long Arity = Expr::proto_arity_c > struct extends; template<typename This, typename Fun, typename Domain> struct virtual_member; struct is_proto_expr; } //////////////////////////////////////////////////////////////////////////////////////////////// using exprns_::expr; using exprns_::basic_expr; using exprns_::extends; using exprns_::is_proto_expr; template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G, void)> struct or_; template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G, void)> struct and_; template<typename Grammar> struct not_; template<typename Condition, typename Then = _, typename Else = not_<_> > struct if_; template<typename Cases, typename Transform = tag_of<_>()> struct switch_; template<typename T> struct exact; template<typename T> struct convertible_to; template<typename Grammar> struct vararg; struct pack; // Boost bug https://svn.boost.org/trac/boost/ticket/4602 //int const N = INT_MAX; int const N = (INT_MAX >> 10); namespace context { struct null_context; template<typename Expr, typename Context, long Arity = Expr::proto_arity_c> struct null_eval; struct default_context; template<typename Expr, typename Context, typename Tag = typename Expr::proto_tag, long Arity = Expr::proto_arity_c> struct default_eval; template<typename Derived, typename DefaultCtx = default_context> struct callable_context; template<typename Expr, typename Context, long Arity = Expr::proto_arity_c> struct callable_eval; } using context::null_context; using context::null_eval; using context::default_context; using context::default_eval; using context::callable_context; using context::callable_eval; namespace utility { template<typename T, typename Domain = default_domain> struct literal; } using utility::literal; namespace result_of { template<typename T, typename Domain = default_domain> struct as_expr; template<typename T, typename Domain = default_domain> struct as_child; template<typename Expr, typename N = mpl::long_<0> > struct child; template<typename Expr, long N> struct child_c; template<typename Expr> struct left; template<typename Expr> struct right; template<typename Expr> struct deep_copy; template<typename Expr, typename Context> struct eval; template< typename Tag , typename DomainOrA0 BOOST_PP_ENUM_TRAILING_BINARY_PARAMS( BOOST_PROTO_MAX_ARITY , typename A , = void BOOST_PP_INTERCEPT ) , typename Void = void > struct make_expr; template<typename Tag, typename DomainOrSequence, typename SequenceOrVoid = void, typename Void = void> struct unpack_expr; template<typename T> struct as_env; template<typename Env, typename Tag> struct has_env_var; template<typename Env, typename Tag> struct env_var; } template<typename T, typename Void = void> struct is_expr; template<typename T, typename Void = void> struct is_domain; template<typename SubDomain, typename SuperDomain> struct is_sub_domain_of; template<typename T, typename Void = void> struct is_env; template<typename Expr> struct arity_of; template<typename T, typename Void = void> struct domain_of; template<typename Expr, typename Grammar> struct matches; // Generic expression metafunctions and // grammar elements template<typename Tag, typename Arg> struct unary_expr; template<typename Tag, typename Left, typename Right> struct binary_expr; template<typename Tag, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void)> struct nary_expr; // Specific expression metafunctions and // grammar elements, for convenience template<typename T> struct terminal; template<typename T> struct unary_plus; template<typename T> struct negate; template<typename T> struct dereference; template<typename T> struct complement; template<typename T> struct address_of; template<typename T> struct logical_not; template<typename T> struct pre_inc; template<typename T> struct pre_dec; template<typename T> struct post_inc; template<typename T> struct post_dec; template<typename T, typename U> struct shift_left; template<typename T, typename U> struct shift_right; template<typename T, typename U> struct multiplies; template<typename T, typename U> struct divides; template<typename T, typename U> struct modulus; template<typename T, typename U> struct plus; template<typename T, typename U> struct minus; template<typename T, typename U> struct less; template<typename T, typename U> struct greater; template<typename T, typename U> struct less_equal; template<typename T, typename U> struct greater_equal; template<typename T, typename U> struct equal_to; template<typename T, typename U> struct not_equal_to; template<typename T, typename U> struct logical_or; template<typename T, typename U> struct logical_and; template<typename T, typename U> struct bitwise_and; template<typename T, typename U> struct bitwise_or; template<typename T, typename U> struct bitwise_xor; template<typename T, typename U> struct comma; template<typename T, typename U> struct mem_ptr; template<typename T, typename U> struct assign; template<typename T, typename U> struct shift_left_assign; template<typename T, typename U> struct shift_right_assign; template<typename T, typename U> struct multiplies_assign; template<typename T, typename U> struct divides_assign; template<typename T, typename U> struct modulus_assign; template<typename T, typename U> struct plus_assign; template<typename T, typename U> struct minus_assign; template<typename T, typename U> struct bitwise_and_assign; template<typename T, typename U> struct bitwise_or_assign; template<typename T, typename U> struct bitwise_xor_assign; template<typename T, typename U> struct subscript; template<typename T, typename U> struct member; template<typename T, typename U, typename V> struct if_else_; template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void)> struct function; namespace functional { struct left; struct right; struct eval; struct deep_copy; template<typename Domain = default_domain> struct as_expr; template<typename Domain = default_domain> struct as_child; template<typename N = mpl::long_<0> > struct child; template<long N> struct child_c; struct as_env; template<typename Tag> struct has_env_var; template<typename Tag> struct env_var; template<typename Tag, typename Domain = deduce_domain> struct make_expr; template<typename Tag, typename Domain = deduce_domain> struct unpack_expr; typedef make_expr<tag::terminal> make_terminal; typedef make_expr<tag::unary_plus> make_unary_plus; typedef make_expr<tag::negate> make_negate; typedef make_expr<tag::dereference> make_dereference; typedef make_expr<tag::complement> make_complement; typedef make_expr<tag::address_of> make_address_of; typedef make_expr<tag::logical_not> make_logical_not; typedef make_expr<tag::pre_inc> make_pre_inc; typedef make_expr<tag::pre_dec> make_pre_dec; typedef make_expr<tag::post_inc> make_post_inc; typedef make_expr<tag::post_dec> make_post_dec; typedef make_expr<tag::shift_left> make_shift_left; typedef make_expr<tag::shift_right> make_shift_right; typedef make_expr<tag::multiplies> make_multiplies; typedef make_expr<tag::divides> make_divides; typedef make_expr<tag::modulus> make_modulus; typedef make_expr<tag::plus> make_plus; typedef make_expr<tag::minus> make_minus; typedef make_expr<tag::less> make_less; typedef make_expr<tag::greater> make_greater; typedef make_expr<tag::less_equal> make_less_equal; typedef make_expr<tag::greater_equal> make_greater_equal; typedef make_expr<tag::equal_to> make_equal_to; typedef make_expr<tag::not_equal_to> make_not_equal_to; typedef make_expr<tag::logical_or> make_logical_or; typedef make_expr<tag::logical_and> make_logical_and; typedef make_expr<tag::bitwise_and> make_bitwise_and; typedef make_expr<tag::bitwise_or> make_bitwise_or; typedef make_expr<tag::bitwise_xor> make_bitwise_xor; typedef make_expr<tag::comma> make_comma; typedef make_expr<tag::mem_ptr> make_mem_ptr; typedef make_expr<tag::assign> make_assign; typedef make_expr<tag::shift_left_assign> make_shift_left_assign; typedef make_expr<tag::shift_right_assign> make_shift_right_assign; typedef make_expr<tag::multiplies_assign> make_multiplies_assign; typedef make_expr<tag::divides_assign> make_divides_assign; typedef make_expr<tag::modulus_assign> make_modulus_assign; typedef make_expr<tag::plus_assign> make_plus_assign; typedef make_expr<tag::minus_assign> make_minus_assign; typedef make_expr<tag::bitwise_and_assign> make_bitwise_and_assign; typedef make_expr<tag::bitwise_or_assign> make_bitwise_or_assign; typedef make_expr<tag::bitwise_xor_assign> make_bitwise_xor_assign; typedef make_expr<tag::subscript> make_subscript; typedef make_expr<tag::if_else_> make_if_else; typedef make_expr<tag::function> make_function; struct flatten; struct make_pair; struct first; struct second; struct at; struct pop_front; struct push_front; struct pop_back; struct push_back; struct reverse; } typedef functional::flatten _flatten; typedef functional::make_pair _make_pair; typedef functional::first _first; typedef functional::second _second; typedef functional::at _at; typedef functional::pop_front _pop_front; typedef functional::push_front _push_front; typedef functional::pop_back _pop_back; typedef functional::push_back _push_back; typedef functional::reverse _reverse; typedef functional::eval _eval; struct _deep_copy; typedef functional::make_expr<tag::terminal> _make_terminal; typedef functional::make_expr<tag::unary_plus> _make_unary_plus; typedef functional::make_expr<tag::negate> _make_negate; typedef functional::make_expr<tag::dereference> _make_dereference; typedef functional::make_expr<tag::complement> _make_complement; typedef functional::make_expr<tag::address_of> _make_address_of; typedef functional::make_expr<tag::logical_not> _make_logical_not; typedef functional::make_expr<tag::pre_inc> _make_pre_inc; typedef functional::make_expr<tag::pre_dec> _make_pre_dec; typedef functional::make_expr<tag::post_inc> _make_post_inc; typedef functional::make_expr<tag::post_dec> _make_post_dec; typedef functional::make_expr<tag::shift_left> _make_shift_left; typedef functional::make_expr<tag::shift_right> _make_shift_right; typedef functional::make_expr<tag::multiplies> _make_multiplies; typedef functional::make_expr<tag::divides> _make_divides; typedef functional::make_expr<tag::modulus> _make_modulus; typedef functional::make_expr<tag::plus> _make_plus; typedef functional::make_expr<tag::minus> _make_minus; typedef functional::make_expr<tag::less> _make_less; typedef functional::make_expr<tag::greater> _make_greater; typedef functional::make_expr<tag::less_equal> _make_less_equal; typedef functional::make_expr<tag::greater_equal> _make_greater_equal; typedef functional::make_expr<tag::equal_to> _make_equal_to; typedef functional::make_expr<tag::not_equal_to> _make_not_equal_to; typedef functional::make_expr<tag::logical_or> _make_logical_or; typedef functional::make_expr<tag::logical_and> _make_logical_and; typedef functional::make_expr<tag::bitwise_and> _make_bitwise_and; typedef functional::make_expr<tag::bitwise_or> _make_bitwise_or; typedef functional::make_expr<tag::bitwise_xor> _make_bitwise_xor; typedef functional::make_expr<tag::comma> _make_comma; typedef functional::make_expr<tag::mem_ptr> _make_mem_ptr; typedef functional::make_expr<tag::assign> _make_assign; typedef functional::make_expr<tag::shift_left_assign> _make_shift_left_assign; typedef functional::make_expr<tag::shift_right_assign> _make_shift_right_assign; typedef functional::make_expr<tag::multiplies_assign> _make_multiplies_assign; typedef functional::make_expr<tag::divides_assign> _make_divides_assign; typedef functional::make_expr<tag::modulus_assign> _make_modulus_assign; typedef functional::make_expr<tag::plus_assign> _make_plus_assign; typedef functional::make_expr<tag::minus_assign> _make_minus_assign; typedef functional::make_expr<tag::bitwise_and_assign> _make_bitwise_and_assign; typedef functional::make_expr<tag::bitwise_or_assign> _make_bitwise_or_assign; typedef functional::make_expr<tag::bitwise_xor_assign> _make_bitwise_xor_assign; typedef functional::make_expr<tag::subscript> _make_subscript; typedef functional::make_expr<tag::if_else_> _make_if_else; typedef functional::make_expr<tag::function> _make_function; template<typename T> struct is_callable; template<typename T> struct is_transform; template<typename T> struct is_aggregate; #define BOOST_PROTO_UNEXPR() typedef int proto_is_expr_; #define BOOST_PROTO_CALLABLE() typedef void proto_is_callable_; #define BOOST_PROTO_AGGREGATE() typedef void proto_is_aggregate_; #define BOOST_PROTO_USE_BASIC_EXPR() typedef void proto_use_basic_expr_; struct callable { BOOST_PROTO_CALLABLE() }; namespace envns_ { struct key_not_found; struct empty_env; typedef int empty_state; template<typename Tag, typename Value, typename Base = empty_env> struct env; struct data_type; struct transforms_type; } using envns_::key_not_found; using envns_::empty_env; using envns_::empty_state; using envns_::env; using envns_::data_type; using envns_::transforms_type; struct external_transform; template<typename PrimitiveTransform = void, typename X = void> struct transform; template<typename Grammar, typename Fun = Grammar> struct when; template<typename Fun> struct otherwise; template<typename Fun> struct call; template<typename Fun> struct make; template<typename PrimitiveTransform> struct protect; template<typename T> struct noinvoke; template<typename Fun> struct lazy; template<typename Sequence, typename State, typename Fun> struct fold; template<typename Sequence, typename State, typename Fun> struct reverse_fold; // Q: can we replace fold_tree with fold<flatten(_), state, fun> ? // A: once segmented Fusion works well. template<typename Sequence, typename State, typename Fun> struct fold_tree; template<typename Sequence, typename State, typename Fun> struct reverse_fold_tree; template<typename Grammar, typename Domain = deduce_domain> struct pass_through; template<typename Grammar = detail::_default> struct _default; struct _expr; struct _state; struct _data; struct _value; struct _void; template<typename T, T I> struct integral_c; template<char I> struct char_; template<int I> struct int_; template<long I> struct long_; template<std::size_t I> struct size_t; template<int I> struct _child_c; typedef _child_c<0> _child0; typedef _child_c<1> _child1; typedef _child0 _child; typedef _child0 _left; typedef _child1 _right; // _child2, _child3, _child4, ... #define M0(Z, N, DATA) typedef _child_c<N> BOOST_PP_CAT(_child, N); BOOST_PP_REPEAT_FROM_TO( 2 , BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY) , M0 , ~ ) #undef M0 struct _byref; struct _byval; template<typename Tag> struct _env_var; struct _env; template<typename T> struct is_extension; namespace exops = exprns_; }} // namespace boost::proto #endif PK �J�[֧�� functional/range.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file range.hpp /// Proto callables for things found in the boost range library // // Copyright 2012 Eric Niebler. 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_PROTO_FUNCTIONAL_RANGE_HPP_EAN_27_08_2012 #define BOOST_PROTO_FUNCTIONAL_RANGE_HPP_EAN_27_08_2012 #include <boost/proto/functional/range/begin.hpp> #include <boost/proto/functional/range/empty.hpp> #include <boost/proto/functional/range/end.hpp> #include <boost/proto/functional/range/rbegin.hpp> #include <boost/proto/functional/range/rend.hpp> #include <boost/proto/functional/range/size.hpp> #endif PK �J�[E~qq q functional/range/begin.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file begin.hpp /// Proto callables for boost::begin() // // Copyright 2012 Eric Niebler. 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_PROTO_FUNCTIONAL_RANGE_BEGIN_HPP_EAN_27_08_2012 #define BOOST_PROTO_FUNCTIONAL_RANGE_BEGIN_HPP_EAN_27_08_2012 #include <boost/range/begin.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace functional { // A PolymorphicFunctionObject that wraps boost::begin() struct begin { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Rng> struct result<This(Rng)> : boost::range_iterator<Rng const> {}; template<typename This, typename Rng> struct result<This(Rng &)> : boost::range_iterator<Rng> {}; template<typename Rng> typename boost::range_iterator<Rng>::type operator()(Rng &rng) const { return boost::begin(rng); } template<typename Rng> typename boost::range_iterator<Rng const>::type operator()(Rng const &rng) const { return boost::begin(rng); } }; }}} #endif PK �J�[��'� � functional/range/rbegin.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file rbegin.hpp /// Proto callables for boost::rbegin() // // Copyright 2012 Eric Niebler. 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_PROTO_FUNCTIONAL_RANGE_RBEGIN_HPP_EAN_27_08_2012 #define BOOST_PROTO_FUNCTIONAL_RANGE_RBEGIN_HPP_EAN_27_08_2012 #include <boost/range/rbegin.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace functional { // A PolymorphicFunctionObject that wraps boost::rbegin() struct rbegin { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Rng> struct result<This(Rng)> : boost::range_reverse_iterator<Rng const> {}; template<typename This, typename Rng> struct result<This(Rng &)> : boost::range_reverse_iterator<Rng> {}; template<typename Rng> typename boost::range_reverse_iterator<Rng>::type operator()(Rng &rng) const { return boost::rbegin(rng); } template<typename Rng> typename boost::range_reverse_iterator<Rng const>::type operator()(Rng const &rng) const { return boost::rbegin(rng); } }; }}} #endif PK �J�[�L�U} } functional/range/empty.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file empty.hpp /// Proto callables for boost::empty() // // Copyright 2012 Eric Niebler. 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_PROTO_FUNCTIONAL_RANGE_EMPTY_HPP_EAN_27_08_2012 #define BOOST_PROTO_FUNCTIONAL_RANGE_EMPTY_HPP_EAN_27_08_2012 #include <boost/range/empty.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace functional { // A PolymorphicFunctionObject that wraps boost::empty() struct empty { BOOST_PROTO_CALLABLE() typedef bool result_type; template<typename Rng> bool operator()(Rng const &rng) const { return boost::empty(rng); } }; }}} #endif PK �J�[�h��_ _ functional/range/end.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file end.hpp /// Proto callables for boost::end() // // Copyright 2012 Eric Niebler. 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_PROTO_FUNCTIONAL_RANGE_END_HPP_EAN_27_08_2012 #define BOOST_PROTO_FUNCTIONAL_RANGE_END_HPP_EAN_27_08_2012 #include <boost/range/end.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace functional { // A PolymorphicFunctionObject that wraps boost::end() struct end { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Rng> struct result<This(Rng)> : boost::range_iterator<Rng const> {}; template<typename This, typename Rng> struct result<This(Rng &)> : boost::range_iterator<Rng> {}; template<typename Rng> typename boost::range_iterator<Rng>::type operator()(Rng &rng) const { return boost::end(rng); } template<typename Rng> typename boost::range_iterator<Rng const>::type operator()(Rng const &rng) const { return boost::end(rng); } }; }}} #endif PK �J�[��a� � functional/range/size.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file size.hpp /// Proto callables for boost::size() // // Copyright 2012 Eric Niebler. 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_PROTO_FUNCTIONAL_RANGE_SIZE_HPP_EAN_27_08_2012 #define BOOST_PROTO_FUNCTIONAL_RANGE_SIZE_HPP_EAN_27_08_2012 #include <boost/range/size.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace functional { // A PolymorphicFunctionObject that wraps boost::size() struct size { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Rng> struct result<This(Rng)> : boost::range_size<Rng> {}; template<typename This, typename Rng> struct result<This(Rng &)> : boost::range_size<Rng> {}; template<typename Rng> typename boost::range_size<Rng>::type operator()(Rng const &rng) const { return boost::size(rng); } }; }}} #endif PK �J�[Gy�� � functional/range/rend.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file rend.hpp /// Proto callables for boost::rend() // // Copyright 2012 Eric Niebler. 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_PROTO_FUNCTIONAL_RANGE_REND_HPP_EAN_27_08_2012 #define BOOST_PROTO_FUNCTIONAL_RANGE_REND_HPP_EAN_27_08_2012 #include <boost/range/rend.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace functional { // A PolymorphicFunctionObject that wraps boost::rend() struct rend { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Rng> struct result<This(Rng)> : boost::range_reverse_iterator<Rng const> {}; template<typename This, typename Rng> struct result<This(Rng &)> : boost::range_reverse_iterator<Rng> {}; template<typename Rng> typename boost::range_reverse_iterator<Rng>::type operator()(Rng &rng) const { return boost::rend(rng); } template<typename Rng> typename boost::range_reverse_iterator<Rng const>::type operator()(Rng const &rng) const { return boost::rend(rng); } }; }}} #endif PK �J�[[�� � functional/fusion/push_front.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file push_front.hpp /// Proto callables Fusion push_front // // Copyright 2010 Eric Niebler. 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_PROTO_FUNCTIONAL_FUSION_PUSH_FRONT_HPP_EAN_11_27_2010 #define BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_FRONT_HPP_EAN_11_27_2010 #include <boost/type_traits/add_const.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/fusion/include/push_front.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace functional { /// \brief A PolymorphicFunctionObject type that invokes the /// \c fusion::push_front() algorithm on its argument. /// /// A PolymorphicFunctionObject type that invokes the /// \c fusion::push_front() algorithm on its argument. struct push_front { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Seq, typename T> struct result<This(Seq, T)> : fusion::result_of::push_front< typename boost::add_const<typename boost::remove_reference<Seq>::type>::type , typename boost::remove_const<typename boost::remove_reference<T>::type>::type > {}; template<typename Seq, typename T> typename fusion::result_of::push_front<Seq const, T>::type operator ()(Seq const &seq, T const &t) const { return fusion::push_front(seq, t); } }; }}} #endif PK �J�[���;� � functional/fusion/push_back.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file push_back.hpp /// Proto callables Fusion push_back // // Copyright 2010 Eric Niebler. 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_PROTO_FUNCTIONAL_FUSION_PUSH_BACK_HPP_EAN_11_27_2010 #define BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_BACK_HPP_EAN_11_27_2010 #include <boost/type_traits/add_const.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/fusion/include/push_back.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace functional { /// \brief A PolymorphicFunctionObject type that invokes the /// \c fusion::push_back() algorithm on its argument. /// /// A PolymorphicFunctionObject type that invokes the /// \c fusion::push_back() algorithm on its argument. struct push_back { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Seq, typename T> struct result<This(Seq, T)> : fusion::result_of::push_back< typename boost::add_const<typename boost::remove_reference<Seq>::type>::type , typename boost::remove_const<typename boost::remove_reference<T>::type>::type > {}; template<typename Seq, typename T> typename fusion::result_of::push_back<Seq const, T>::type operator ()(Seq const &seq, T const &t) const { return fusion::push_back(seq, t); } }; }}} #endif PK �J�[?;�;� � functional/fusion/pop_front.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file pop_front.hpp /// Proto callables Fusion pop_front // // Copyright 2010 Eric Niebler. 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_PROTO_FUNCTIONAL_FUSION_POP_FRONT_HPP_EAN_11_27_2010 #define BOOST_PROTO_FUNCTIONAL_FUSION_POP_FRONT_HPP_EAN_11_27_2010 #include <boost/fusion/include/begin.hpp> #include <boost/fusion/include/end.hpp> #include <boost/fusion/include/next.hpp> #include <boost/fusion/include/pop_front.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace functional { /// \brief A PolymorphicFunctionObject type that invokes the /// \c fusion::pop_front() algorithm on its argument. /// /// A PolymorphicFunctionObject type that invokes the /// \c fusion::pop_front() algorithm on its argument. This is /// useful for defining a CallableTransform like \c pop_front(_) /// which removes the first child from a Proto expression node. /// Such a transform might be used as the first argument to the /// \c proto::fold\<\> transform; that is, fold all but /// the first child. struct pop_front { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Seq> struct result<This(Seq)> : result<This(Seq const &)> {}; template<typename This, typename Seq> struct result<This(Seq &)> : fusion::result_of::pop_front<Seq> {}; template<typename Seq> typename fusion::result_of::pop_front<Seq>::type operator ()(Seq &seq) const { // Work around a const-correctness issue in Fusion typedef typename fusion::result_of::pop_front<Seq>::type result_type; return result_type(fusion::next(fusion::begin(seq)), fusion::end(seq)); } template<typename Seq> typename fusion::result_of::pop_front<Seq const>::type operator ()(Seq const &seq) const { return fusion::pop_front(seq); } }; }}} #endif PK �J�[�pꁁ � functional/fusion/reverse.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file reverse.hpp /// Proto callables Fusion reverse // // Copyright 2010 Eric Niebler. 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_PROTO_FUNCTIONAL_FUSION_REVERSE_HPP_EAN_11_27_2010 #define BOOST_PROTO_FUNCTIONAL_FUSION_REVERSE_HPP_EAN_11_27_2010 #include <boost/fusion/include/reverse.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace functional { /// \brief A PolymorphicFunctionObject type that invokes the /// \c fusion::reverse() algorithm on its argument. /// /// A PolymorphicFunctionObject type that invokes the /// \c fusion::reverse() algorithm on its argument. This is /// useful for defining a CallableTransform like \c reverse(_) /// which reverses the order of the children of a Proto /// expression node. struct reverse { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Seq> struct result<This(Seq)> : result<This(Seq const &)> {}; template<typename This, typename Seq> struct result<This(Seq &)> : fusion::result_of::reverse<Seq> {}; template<typename Seq> typename fusion::result_of::reverse<Seq>::type operator ()(Seq &seq) const { // Work around a const-correctness issue in Fusion typedef typename fusion::result_of::reverse<Seq>::type result_type; return result_type(seq); } template<typename Seq> typename fusion::result_of::reverse<Seq const>::type operator ()(Seq const &seq) const { return fusion::reverse(seq); } }; }}} #endif PK �J�[��� � functional/fusion/pop_back.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file pop_back.hpp /// Proto callables Fusion pop_back // // Copyright 2010 Eric Niebler. 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_PROTO_FUNCTIONAL_FUSION_POP_BACK_HPP_EAN_11_27_2010 #define BOOST_PROTO_FUNCTIONAL_FUSION_POP_BACK_HPP_EAN_11_27_2010 #include <boost/fusion/include/begin.hpp> #include <boost/fusion/include/end.hpp> #include <boost/fusion/include/prior.hpp> #include <boost/fusion/include/pop_back.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace functional { /// \brief A PolymorphicFunctionObject type that invokes the /// \c fusion::pop_back() algorithm on its argument. /// /// A PolymorphicFunctionObject type that invokes the /// \c fusion::pop_back() algorithm on its argument. struct pop_back { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Seq> struct result<This(Seq)> : result<This(Seq const &)> {}; template<typename This, typename Seq> struct result<This(Seq &)> : fusion::result_of::pop_back<Seq> {}; template<typename Seq> typename fusion::result_of::pop_back<Seq>::type operator ()(Seq &seq) const { // Work around a const-correctness issue in Fusion typedef typename fusion::result_of::pop_back<Seq>::type result_type; return result_type(fusion::begin(seq), fusion::prior(fusion::end(seq))); } template<typename Seq> typename fusion::result_of::pop_back<Seq const>::type operator ()(Seq const &seq) const { return fusion::pop_back(seq); } }; }}} #endif PK �J�[��8�, , functional/fusion/at.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file at.hpp /// Proto callables Fusion at // // Copyright 2010 Eric Niebler. 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_PROTO_FUNCTIONAL_FUSION_AT_HPP_EAN_11_27_2010 #define BOOST_PROTO_FUNCTIONAL_FUSION_AT_HPP_EAN_11_27_2010 #include <boost/type_traits/add_const.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/fusion/include/at.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace functional { /// \brief A PolymorphicFunctionObject type that invokes the /// \c fusion::at() accessor on its argument. /// /// A PolymorphicFunctionObject type that invokes the /// \c fusion::at() accessor on its argument. struct at { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Seq, typename N> struct result<This(Seq, N)> : fusion::result_of::at< typename boost::remove_reference<Seq>::type , typename boost::remove_const<typename boost::remove_reference<N>::type>::type > {}; template<typename Seq, typename N> typename fusion::result_of::at<Seq, N>::type operator ()(Seq &seq, N const & BOOST_PROTO_DISABLE_IF_IS_CONST(Seq)) const { return fusion::at<N>(seq); } template<typename Seq, typename N> typename fusion::result_of::at<Seq const, N>::type operator ()(Seq const &seq, N const &) const { return fusion::at<N>(seq); } }; }}} #endif PK �J�[��LO O functional/std/utility.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file utility.hpp /// Proto callables for things found in the std \<utility\> header // // Copyright 2010 Eric Niebler. 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_PROTO_FUNCTIONAL_STD_UTILITY_HPP_EAN_11_27_2010 #define BOOST_PROTO_FUNCTIONAL_STD_UTILITY_HPP_EAN_11_27_2010 #include <utility> #include <boost/type_traits/remove_const.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace functional { /// \brief A PolymorphicFunctionObject type that invokes the /// \c std::make_pair() algorithm on its arguments. /// /// A PolymorphicFunctionObject type that invokes the /// \c std::make_pair() algorithm on its arguments. struct make_pair { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename First, typename Second> struct result<This(First, Second)> { typedef std::pair< typename remove_const<typename remove_reference<First>::type>::type , typename remove_const<typename remove_reference<Second>::type>::type > type; }; template<typename First, typename Second> std::pair<First, Second> operator()(First const &first, Second const &second) const { return std::make_pair(first, second); } }; /// \brief A PolymorphicFunctionObject type that returns /// the first element of a std::pair. /// /// A PolymorphicFunctionObject type that returns /// the first element of a std::pair.. struct first { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Pair> struct result<This(Pair)> { typedef typename Pair::first_type type; }; template<typename This, typename Pair> struct result<This(Pair &)> { typedef typename Pair::first_type &type; }; template<typename This, typename Pair> struct result<This(Pair const &)> { typedef typename Pair::first_type const &type; }; template<typename Pair> typename Pair::first_type &operator()(Pair &pair) const { return pair.first; } template<typename Pair> typename Pair::first_type const &operator()(Pair const &pair) const { return pair.first; } }; /// \brief A PolymorphicFunctionObject type that returns /// the second element of a std::pair. /// /// A PolymorphicFunctionObject type that returns /// the second element of a std::pair.. struct second { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Pair> struct result<This(Pair)> { typedef typename Pair::second_type type; }; template<typename This, typename Pair> struct result<This(Pair &)> { typedef typename Pair::second_type &type; }; template<typename This, typename Pair> struct result<This(Pair const &)> { typedef typename Pair::second_type const &type; }; template<typename Pair> typename Pair::second_type &operator()(Pair &pair) const { return pair.second; } template<typename Pair> typename Pair::second_type const &operator()(Pair const &pair) const { return pair.second; } }; }}} #endif PK �J�[��S] ] functional/std/iterator.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file iterator.hpp /// Proto callables for std functions found in \<iterator\> // // Copyright 2012 Eric Niebler. 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_PROTO_FUNCTIONAL_STD_ITERATOR_HPP_EAN_27_08_2012 #define BOOST_PROTO_FUNCTIONAL_STD_ITERATOR_HPP_EAN_27_08_2012 #include <iterator> #include <boost/type_traits/remove_const.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace functional { // A PolymorphicFunctionObject wrapping std::advance struct advance { BOOST_PROTO_CALLABLE() typedef void result_type; template<typename InputIterator, typename Distance> void operator()(InputIterator &x, Distance n) const { std::advance(x, n); } }; // A PolymorphicFunctionObject wrapping std::distance struct distance { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename InputIter1, typename InputIter2> struct result<This(InputIter1, InputIter2)> { typedef typename std::iterator_traits< typename boost::remove_const< typename boost::remove_reference<InputIter1>::type >::type >::difference_type type; }; template<typename InputIterator> typename std::iterator_traits<InputIterator>::difference_type operator()(InputIterator first, InputIterator last) const { return std::distance(first, last); } }; // A PolymorphicFunctionObject wrapping std::next struct next { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename ForwardIterator> struct result<This(ForwardIterator)> { typedef typename boost::remove_const< typename boost::remove_reference<ForwardIterator>::type >::type type; }; template<typename This, typename ForwardIterator, typename Distance> struct result<This(ForwardIterator, Distance)> { typedef typename boost::remove_const< typename boost::remove_reference<ForwardIterator>::type >::type type; }; template<typename ForwardIterator> ForwardIterator operator()(ForwardIterator x) const { return std::advance( x , static_cast<typename std::iterator_traits<ForwardIterator>::difference_type>(1) ); } template<typename ForwardIterator> ForwardIterator operator()( ForwardIterator x , typename std::iterator_traits<ForwardIterator>::difference_type n ) const { return std::advance(x, n); } }; // A PolymorphicFunctionObject wrapping std::prior struct prior { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename BidirectionalIterator> struct result<This(BidirectionalIterator)> { typedef typename boost::remove_const< typename boost::remove_reference<BidirectionalIterator>::type >::type type; }; template<typename This, typename BidirectionalIterator, typename Distance> struct result<This(BidirectionalIterator, Distance)> { typedef typename boost::remove_const< typename boost::remove_reference<BidirectionalIterator>::type >::type type; }; template<typename BidirectionalIterator> BidirectionalIterator operator()(BidirectionalIterator x) const { return std::advance( x , -static_cast<typename std::iterator_traits<BidirectionalIterator>::difference_type>(1) ); } template<typename BidirectionalIterator> BidirectionalIterator operator()( BidirectionalIterator x , typename std::iterator_traits<BidirectionalIterator>::difference_type n ) const { return std::advance(x, -n); } }; }}} #endif PK �J�[m�" functional/fusion.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file fusion.hpp /// Proto callables for things found in the Fusion library // // Copyright 2010 Eric Niebler. 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_PROTO_FUNCTIONAL_FUSION_HPP_EAN_11_27_2010 #define BOOST_PROTO_FUNCTIONAL_FUSION_HPP_EAN_11_27_2010 #include <boost/proto/functional/fusion/at.hpp> #include <boost/proto/functional/fusion/pop_back.hpp> #include <boost/proto/functional/fusion/pop_front.hpp> #include <boost/proto/functional/fusion/push_back.hpp> #include <boost/proto/functional/fusion/push_front.hpp> #include <boost/proto/functional/fusion/reverse.hpp> #endif PK �J�[�� 4 4 functional/std.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file std.hpp /// Proto callables for things found in the std library // // Copyright 2010 Eric Niebler. 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_PROTO_FUNCTIONAL_STD_HPP_EAN_11_27_2010 #define BOOST_PROTO_FUNCTIONAL_STD_HPP_EAN_11_27_2010 #include <boost/proto/functional/std/utility.hpp> #include <boost/proto/functional/std/iterator.hpp> #endif PK �J�[�c:� � args.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file args.hpp /// Contains definition of \c term\<\>, \c list1\<\>, \c list2\<\>, ... /// class templates. // // Copyright 2008 Eric Niebler. 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_PROTO_ARGS_HPP_EAN_04_01_2005 #define BOOST_PROTO_ARGS_HPP_EAN_04_01_2005 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/void.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/detail/is_noncopyable.hpp> #include <boost/mpl/or.hpp> #include <boost/type_traits/is_function.hpp> #include <boost/type_traits/is_abstract.hpp> namespace boost { namespace proto { namespace detail { /// INTERNAL ONLY template<typename Expr> struct expr_traits { typedef Expr value_type; typedef Expr &reference; typedef Expr const &const_reference; }; /// INTERNAL ONLY template<typename Expr> struct expr_traits<Expr &> { typedef Expr value_type; typedef Expr &reference; typedef Expr &const_reference; }; /// INTERNAL ONLY template<typename Expr> struct expr_traits<Expr const &> { typedef Expr value_type; typedef Expr const &reference; typedef Expr const &const_reference; }; /// INTERNAL ONLY template<typename T> struct term_traits { typedef T value_type; typedef T &reference; typedef T const &const_reference; }; /// INTERNAL ONLY template<typename T> struct term_traits<T &> { typedef typename mpl::if_c<is_noncopyable<T>::value, T &, T>::type value_type; typedef T &reference; typedef T &const_reference; }; /// INTERNAL ONLY template<typename T> struct term_traits<T const &> { typedef T value_type; typedef T const &reference; typedef T const &const_reference; }; /// INTERNAL ONLY template<typename T, std::size_t N> struct term_traits<T (&)[N]> { typedef T value_type[N]; typedef T (&reference)[N]; typedef T (&const_reference)[N]; }; /// INTERNAL ONLY template<typename T, std::size_t N> struct term_traits<T const (&)[N]> { typedef T value_type[N]; typedef T const (&reference)[N]; typedef T const (&const_reference)[N]; }; /// INTERNAL ONLY template<typename T, std::size_t N> struct term_traits<T[N]> { typedef T value_type[N]; typedef T (&reference)[N]; typedef T const (&const_reference)[N]; }; /// INTERNAL ONLY template<typename T, std::size_t N> struct term_traits<T const[N]> { typedef T value_type[N]; typedef T const (&reference)[N]; typedef T const (&const_reference)[N]; }; } namespace argsns_ { // This is where term and all the different listN templates are defined #include <boost/proto/detail/args.hpp> } }} #endif PK �J�[�� �� � matches.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file matches.hpp /// Contains definition of matches\<\> metafunction for determining if /// a given expression matches a given pattern. // // Copyright 2008 Eric Niebler. 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_PROTO_MATCHES_HPP_EAN_11_03_2006 #define BOOST_PROTO_MATCHES_HPP_EAN_11_03_2006 #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/arithmetic/sub.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/punctuation/comma_if.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_shifted.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_shifted_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/config.hpp> #include <boost/mpl/logical.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/proto/detail/template_arity.hpp> #include <boost/utility/enable_if.hpp> #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) #include <boost/type_traits/is_array.hpp> #endif #include <boost/type_traits/is_const.hpp> #include <boost/type_traits/is_convertible.hpp> #include <boost/type_traits/is_reference.hpp> #include <boost/type_traits/is_pointer.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/transform/when.hpp> #include <boost/proto/transform/impl.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable:4305) // 'specialization' : truncation from 'const int' to 'bool' #endif #define BOOST_PROTO_LOGICAL_typename_G BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G) #define BOOST_PROTO_LOGICAL_G BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, G) namespace boost { namespace proto { namespace detail { template<typename Expr, typename BasicExpr, typename Grammar> struct matches_; template<bool B, typename Pred> struct and_2; template<typename And, typename Expr, typename State, typename Data> struct _and_impl; template<typename T, typename U> struct array_matches : mpl::false_ {}; template<typename T, std::size_t M> struct array_matches<T[M], T *> : mpl::true_ {}; template<typename T, std::size_t M> struct array_matches<T[M], T const *> : mpl::true_ {}; template<typename T, std::size_t M> struct array_matches<T[M], T[proto::N]> : mpl::true_ {}; template<typename T, typename U BOOST_PROTO_TEMPLATE_ARITY_PARAM(long Arity = detail::template_arity<U>::value) > struct lambda_matches : mpl::false_ {}; template<typename T> struct lambda_matches<T, proto::_ BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)> : mpl::true_ {}; template<typename T> struct lambda_matches<T, T BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)> : mpl::true_ {}; template<typename T, std::size_t M, typename U> struct lambda_matches<T[M], U BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)> : array_matches<T[M], U> {}; template<typename T, std::size_t M> struct lambda_matches<T[M], _ BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)> : mpl::true_ {}; template<typename T, std::size_t M> struct lambda_matches<T[M], T[M] BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)> : mpl::true_ {}; template<template<typename> class T, typename Expr0, typename Grammar0> struct lambda_matches<T<Expr0>, T<Grammar0> BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) > : lambda_matches<Expr0, Grammar0> {}; // vararg_matches_impl template<typename Args1, typename Back, long From, long To> struct vararg_matches_impl; // vararg_matches template<typename Expr, typename Args1, typename Args2, typename Back, bool Can, bool Zero, typename Void = void> struct vararg_matches : mpl::false_ {}; template<typename Expr, typename Args1, typename Args2, typename Back> struct vararg_matches<Expr, Args1, Args2, Back, true, true, typename Back::proto_is_vararg_> : matches_< Expr , proto::basic_expr<ignore, Args1, Args1::arity> , proto::basic_expr<ignore, Args2, Args1::arity> > {}; template<typename Expr, typename Args1, typename Args2, typename Back> struct vararg_matches<Expr, Args1, Args2, Back, true, false, typename Back::proto_is_vararg_> : and_2< matches_< Expr , proto::basic_expr<ignore, Args1, Args2::arity> , proto::basic_expr<ignore, Args2, Args2::arity> >::value , vararg_matches_impl<Args1, typename Back::proto_grammar, Args2::arity + 1, Args1::arity> > {}; // How terminal_matches<> handles references and cv-qualifiers. // The cv and ref matter *only* if the grammar has a top-level ref. // // Expr | Grammar | Matches? // ------------------------------------- // T T yes // T & T yes // T const & T yes // T T & no // T & T & yes // T const & T & no // T T const & no // T & T const & no // T const & T const & yes template<typename T, typename U> struct is_cv_ref_compatible : mpl::true_ {}; template<typename T, typename U> struct is_cv_ref_compatible<T, U &> : mpl::false_ {}; template<typename T, typename U> struct is_cv_ref_compatible<T &, U &> : mpl::bool_<is_const<T>::value == is_const<U>::value> {}; #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) // MSVC-7.1 has lots of problems with array types that have been // deduced. Partially specializing terminal_matches<> on array types // doesn't seem to work. template< typename T , typename U , bool B = is_array<BOOST_PROTO_UNCVREF(T)>::value > struct terminal_array_matches : mpl::false_ {}; template<typename T, typename U, std::size_t M> struct terminal_array_matches<T, U(&)[M], true> : is_convertible<T, U(&)[M]> {}; template<typename T, typename U> struct terminal_array_matches<T, U(&)[proto::N], true> : is_convertible<T, U *> {}; template<typename T, typename U> struct terminal_array_matches<T, U *, true> : is_convertible<T, U *> {}; // terminal_matches template<typename T, typename U> struct terminal_matches : mpl::or_< mpl::and_< is_cv_ref_compatible<T, U> , lambda_matches< BOOST_PROTO_UNCVREF(T) , BOOST_PROTO_UNCVREF(U) > > , terminal_array_matches<T, U> > {}; #else // terminal_matches template<typename T, typename U> struct terminal_matches : mpl::and_< is_cv_ref_compatible<T, U> , lambda_matches< BOOST_PROTO_UNCVREF(T) , BOOST_PROTO_UNCVREF(U) > > {}; template<typename T, std::size_t M> struct terminal_matches<T(&)[M], T(&)[proto::N]> : mpl::true_ {}; template<typename T, std::size_t M> struct terminal_matches<T(&)[M], T *> : mpl::true_ {}; // Avoid ambiguity errors on MSVC #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) template<typename T, std::size_t M> struct terminal_matches<T const (&)[M], T const[M]> : mpl::true_ {}; #endif #endif template<typename T> struct terminal_matches<T, T> : mpl::true_ {}; template<typename T> struct terminal_matches<T &, T> : mpl::true_ {}; template<typename T> struct terminal_matches<T const &, T> : mpl::true_ {}; template<typename T> struct terminal_matches<T, proto::_> : mpl::true_ {}; template<typename T> struct terminal_matches<T, exact<T> > : mpl::true_ {}; template<typename T, typename U> struct terminal_matches<T, proto::convertible_to<U> > : is_convertible<T, U> {}; // matches_ template<typename Expr, typename BasicExpr, typename Grammar> struct matches_ : mpl::false_ {}; template<typename Expr, typename BasicExpr> struct matches_< Expr, BasicExpr, proto::_ > : mpl::true_ {}; template<typename Expr, typename Tag, typename Args1, long N1, typename Args2, long N2> struct matches_< Expr, proto::basic_expr<Tag, Args1, N1>, proto::basic_expr<Tag, Args2, N2> > : vararg_matches< Expr, Args1, Args2, typename Args2::back_, (N1+2 > N2), (N2 > N1) > {}; template<typename Expr, typename Tag, typename Args1, long N1, typename Args2, long N2> struct matches_< Expr, proto::basic_expr<Tag, Args1, N1>, proto::basic_expr<proto::_, Args2, N2> > : vararg_matches< Expr, Args1, Args2, typename Args2::back_, (N1+2 > N2), (N2 > N1) > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<Tag, Args2, 0> > : terminal_matches<typename Args1::child0, typename Args2::child0> {}; template<typename Expr, typename Tag, typename Args1, typename Args2, long N2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<proto::_, Args2, N2> > : mpl::false_ {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<proto::_, Args2, 0> > : terminal_matches<typename Args1::child0, typename Args2::child0> {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 1>, proto::basic_expr<Tag, Args2, 1> > : matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 1>, proto::basic_expr<proto::_, Args2, 1> > : matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar > {}; #include <boost/proto/detail/and_n.hpp> #include <boost/proto/detail/or_n.hpp> #include <boost/proto/detail/matches_.hpp> #include <boost/proto/detail/vararg_matches_impl.hpp> #include <boost/proto/detail/lambda_matches.hpp> // handle proto::if_ template<typename Expr, typename Tag, typename Args, long Arity, typename If, typename Then, typename Else> struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, proto::if_<If, Then, Else> > : mpl::eval_if_c< static_cast<bool>( remove_reference< typename when<_, If>::template impl<Expr, int, int>::result_type >::type::value ) , matches_<Expr, proto::basic_expr<Tag, Args, Arity>, typename Then::proto_grammar> , matches_<Expr, proto::basic_expr<Tag, Args, Arity>, typename Else::proto_grammar> >::type { typedef typename mpl::if_c< static_cast<bool>( remove_reference< typename when<_, If>::template impl<Expr, int, int>::result_type >::type::value ) , Then , Else >::type which; }; // handle degenerate cases of proto::or_ template<typename Expr, typename BasicExpr> struct matches_<Expr, BasicExpr, or_<> > : mpl::false_ { typedef not_<_> which; }; template<typename Expr, typename BasicExpr, typename G0> struct matches_<Expr, BasicExpr, or_<G0> > : matches_<Expr, BasicExpr, typename G0::proto_grammar> { typedef G0 which; }; // handle degenerate cases of proto::and_ template<typename Expr, typename BasicExpr> struct matches_<Expr, BasicExpr, and_<> > : mpl::true_ {}; template<typename Expr, typename BasicExpr, typename G0> struct matches_<Expr, BasicExpr, and_<G0> > : matches_<Expr, BasicExpr, typename G0::proto_grammar> {}; // handle proto::not_ template<typename Expr, typename BasicExpr, typename Grammar> struct matches_<Expr, BasicExpr, not_<Grammar> > : mpl::not_<matches_<Expr, BasicExpr, typename Grammar::proto_grammar> > {}; // handle proto::switch_ template<typename Expr, typename Tag, typename Args, long Arity, typename Cases, typename Transform> struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, switch_<Cases, Transform> > : matches_< Expr , proto::basic_expr<Tag, Args, Arity> , typename Cases::template case_< typename when<_,Transform>::template impl<Expr,int,int>::result_type >::proto_grammar > { typedef typename Cases::template case_< typename when<_, Transform>::template impl<Expr, int, int>::result_type > which; }; // handle proto::switch_ with the default Transform for specially for better compile times template<typename Expr, typename Tag, typename Args, long Arity, typename Cases> struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, switch_<Cases> > : matches_< Expr , proto::basic_expr<Tag, Args, Arity> , typename Cases::template case_<Tag>::proto_grammar > { typedef typename Cases::template case_<Tag> which; }; } /// \brief A Boolean metafunction that evaluates whether a given /// expression type matches a grammar. /// /// <tt>matches\<Expr,Grammar\></tt> inherits (indirectly) from /// \c mpl::true_ if <tt>Expr::proto_grammar</tt> matches /// <tt>Grammar::proto_grammar</tt>, and from \c mpl::false_ /// otherwise. /// /// Non-terminal expressions are matched against a grammar /// according to the following rules: /// /// \li The wildcard pattern, \c _, matches any expression. /// \li An expression <tt>expr\<AT, listN\<A0,A1,...An\> \></tt> /// matches a grammar <tt>expr\<BT, listN\<B0,B1,...Bn\> \></tt> /// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx for /// each \c x in <tt>[0,n)</tt>. /// \li An expression <tt>expr\<AT, listN\<A0,...An,U0,...Um\> \></tt> /// matches a grammar <tt>expr\<BT, listM\<B0,...Bn,vararg\<V\> \> \></tt> /// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx /// for each \c x in <tt>[0,n)</tt> and if \c Ux matches \c V /// for each \c x in <tt>[0,m)</tt>. /// \li An expression \c E matches <tt>or_\<B0,B1,...Bn\></tt> if \c E /// matches some \c Bx for \c x in <tt>[0,n)</tt>. /// \li An expression \c E matches <tt>and_\<B0,B1,...Bn\></tt> if \c E /// matches all \c Bx for \c x in <tt>[0,n)</tt>. /// \li An expression \c E matches <tt>if_\<T,U,V\></tt> if /// <tt>boost::result_of\<when\<_,T\>(E,int,int)\>::type::value</tt> /// is \c true and \c E matches \c U; or, if /// <tt>boost::result_of\<when\<_,T\>(E,int,int)\>::type::value</tt> /// is \c false and \c E matches \c V. (Note: \c U defaults to \c _ /// and \c V defaults to \c not_\<_\>.) /// \li An expression \c E matches <tt>not_\<T\></tt> if \c E does /// not match \c T. /// \li An expression \c E matches <tt>switch_\<C,T\></tt> if /// \c E matches <tt>C::case_\<boost::result_of\<T(E)\>::type\></tt>. /// (Note: T defaults to <tt>tag_of\<_\>()</tt>.) /// /// A terminal expression <tt>expr\<AT,term\<A\> \></tt> matches /// a grammar <tt>expr\<BT,term\<B\> \></tt> if \c BT is \c AT or /// \c proto::_ and if one of the following is true: /// /// \li \c B is the wildcard pattern, \c _ /// \li \c A is \c B /// \li \c A is <tt>B &</tt> /// \li \c A is <tt>B const &</tt> /// \li \c B is <tt>exact\<A\></tt> /// \li \c B is <tt>convertible_to\<X\></tt> and /// <tt>is_convertible\<A,X\>::value</tt> is \c true. /// \li \c A is <tt>X[M]</tt> or <tt>X(&)[M]</tt> and /// \c B is <tt>X[proto::N]</tt>. /// \li \c A is <tt>X(&)[M]</tt> and \c B is <tt>X(&)[proto::N]</tt>. /// \li \c A is <tt>X[M]</tt> or <tt>X(&)[M]</tt> and /// \c B is <tt>X*</tt>. /// \li \c B lambda-matches \c A (see below). /// /// A type \c B lambda-matches \c A if one of the following is true: /// /// \li \c B is \c A /// \li \c B is the wildcard pattern, \c _ /// \li \c B is <tt>T\<B0,B1,...Bn\></tt> and \c A is /// <tt>T\<A0,A1,...An\></tt> and for each \c x in /// <tt>[0,n)</tt>, \c Ax and \c Bx are types /// such that \c Ax lambda-matches \c Bx template<typename Expr, typename Grammar> struct matches : detail::matches_< typename Expr::proto_derived_expr , typename Expr::proto_grammar , typename Grammar::proto_grammar > {}; /// INTERNAL ONLY /// template<typename Expr, typename Grammar> struct matches<Expr &, Grammar> : detail::matches_< typename Expr::proto_derived_expr , typename Expr::proto_grammar , typename Grammar::proto_grammar > {}; /// \brief A wildcard grammar element that matches any expression, /// and a transform that returns the current expression unchanged. /// /// The wildcard type, \c _, is a grammar element such that /// <tt>matches\<E,_\>::value</tt> is \c true for any expression /// type \c E. /// /// The wildcard can also be used as a stand-in for a template /// argument when matching terminals. For instance, the following /// is a grammar that will match any <tt>std::complex\<\></tt> /// terminal: /// /// \code /// BOOST_MPL_ASSERT(( /// matches< /// terminal<std::complex<double> >::type /// , terminal<std::complex< _ > > /// > /// )); /// \endcode /// /// When used as a transform, \c _ returns the current expression /// unchanged. For instance, in the following, \c _ is used with /// the \c fold\<\> transform to fold the children of a node: /// /// \code /// struct CountChildren /// : or_< /// // Terminals have no children /// when<terminal<_>, mpl::int_<0>()> /// // Use fold<> to count the children of non-terminals /// , otherwise< /// fold< /// _ // <-- fold the current expression /// , mpl::int_<0>() /// , mpl::plus<_state, mpl::int_<1> >() /// > /// > /// > /// {}; /// \endcode struct _ : transform<_> { typedef _ proto_grammar; template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef Expr result_type; /// \param expr An expression /// \return \c e BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param) operator()( typename impl::expr_param e , typename impl::state_param , typename impl::data_param ) const { return e; } }; }; namespace detail { template<typename Expr, typename State, typename Data> struct _and_impl<proto::and_<>, Expr, State, Data> : proto::_::impl<Expr, State, Data> {}; template<typename G0, typename Expr, typename State, typename Data> struct _and_impl<proto::and_<G0>, Expr, State, Data> : proto::when<proto::_, G0>::template impl<Expr, State, Data> {}; } /// \brief Inverts the set of expressions matched by a grammar. When /// used as a transform, \c not_\<\> returns the current expression /// unchanged. /// /// If an expression type \c E does not match a grammar \c G, then /// \c E \e does match <tt>not_\<G\></tt>. For example, /// <tt>not_\<terminal\<_\> \></tt> will match any non-terminal. template<typename Grammar> struct not_ : transform<not_<Grammar> > { typedef not_ proto_grammar; template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef Expr result_type; /// \param e An expression /// \pre <tt>matches\<Expr,not_\>::value</tt> is \c true. /// \return \c e BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param) operator()( typename impl::expr_param e , typename impl::state_param , typename impl::data_param ) const { return e; } }; }; /// \brief Used to select one grammar or another based on the result /// of a compile-time Boolean. When used as a transform, \c if_\<\> /// selects between two transforms based on a compile-time Boolean. /// /// When <tt>if_\<If,Then,Else\></tt> is used as a grammar, \c If /// must be a Proto transform and \c Then and \c Else must be grammars. /// An expression type \c E matches <tt>if_\<If,Then,Else\></tt> if /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt> /// is \c true and \c E matches \c U; or, if /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt> /// is \c false and \c E matches \c V. /// /// The template parameter \c Then defaults to \c _ /// and \c Else defaults to \c not\<_\>, so an expression type \c E /// will match <tt>if_\<If\></tt> if and only if /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt> /// is \c true. /// /// \code /// // A grammar that only matches integral terminals, /// // using is_integral<> from Boost.Type_traits. /// struct IsIntegral /// : and_< /// terminal<_> /// , if_< is_integral<_value>() > /// > /// {}; /// \endcode /// /// When <tt>if_\<If,Then,Else\></tt> is used as a transform, \c If, /// \c Then and \c Else must be Proto transforms. When applying /// the transform to an expression \c E, state \c S and data \c V, /// if <tt>boost::result_of\<when\<_,If\>(E,S,V)\>::type::value</tt> /// is \c true then the \c Then transform is applied; otherwise /// the \c Else transform is applied. /// /// \code /// // Match a terminal. If the terminal is integral, return /// // mpl::true_; otherwise, return mpl::false_. /// struct IsIntegral2 /// : when< /// terminal<_> /// , if_< /// is_integral<_value>() /// , mpl::true_() /// , mpl::false_() /// > /// > /// {}; /// \endcode template< typename If , typename Then // = _ , typename Else // = not_<_> > struct if_ : transform<if_<If, Then, Else> > { typedef if_ proto_grammar; template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename when<_, If>::template impl<Expr, State, Data>::result_type condition; typedef typename mpl::if_c< static_cast<bool>(remove_reference<condition>::type::value) , when<_, Then> , when<_, Else> >::type which; typedef typename which::template impl<Expr, State, Data>::result_type result_type; /// \param e An expression /// \param s The current state /// \param d A data of arbitrary type /// \return <tt>which::impl<Expr, State, Data>()(e, s, d)</tt> result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return typename which::template impl<Expr, State, Data>()(e, s, d); } }; }; /// \brief For matching one of a set of alternate grammars. Alternates /// tried in order to avoid ambiguity. When used as a transform, \c or_\<\> /// applies the transform associated with the first grammar that matches /// the expression. /// /// An expression type \c E matches <tt>or_\<B0,B1,...Bn\></tt> if \c E /// matches any \c Bx for \c x in <tt>[0,n)</tt>. /// /// When applying <tt>or_\<B0,B1,...Bn\></tt> as a transform with an /// expression \c e of type \c E, state \c s and data \c d, it is /// equivalent to <tt>Bx()(e, s, d)</tt>, where \c x is the lowest /// number such that <tt>matches\<E,Bx\>::value</tt> is \c true. template<BOOST_PROTO_LOGICAL_typename_G> struct or_ : transform<or_<BOOST_PROTO_LOGICAL_G> > { typedef or_ proto_grammar; /// \param e An expression /// \param s The current state /// \param d A data of arbitrary type /// \pre <tt>matches\<Expr,or_\>::value</tt> is \c true. /// \return <tt>which()(e, s, d)</tt>, where <tt>which</tt> is the /// sub-grammar that matched <tt>Expr</tt>. template<typename Expr, typename State, typename Data> struct impl : detail::matches_< typename Expr::proto_derived_expr , typename Expr::proto_grammar , or_ >::which::template impl<Expr, State, Data> {}; template<typename Expr, typename State, typename Data> struct impl<Expr &, State, Data> : detail::matches_< typename Expr::proto_derived_expr , typename Expr::proto_grammar , or_ >::which::template impl<Expr &, State, Data> {}; }; /// \brief For matching all of a set of grammars. When used as a /// transform, \c and_\<\> applies the transforms associated with /// the each grammar in the set, and returns the result of the last. /// /// An expression type \c E matches <tt>and_\<B0,B1,...Bn\></tt> if \c E /// matches all \c Bx for \c x in <tt>[0,n)</tt>. /// /// When applying <tt>and_\<B0,B1,...Bn\></tt> as a transform with an /// expression \c e, state \c s and data \c d, it is /// equivalent to <tt>(B0()(e, s, d),B1()(e, s, d),...Bn()(e, s, d))</tt>. template<BOOST_PROTO_LOGICAL_typename_G> struct and_ : transform<and_<BOOST_PROTO_LOGICAL_G> > { typedef and_ proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::_and_impl<and_, Expr, State, Data> {}; }; /// \brief For matching one of a set of alternate grammars, which /// are looked up based on some property of an expression. The /// property on which to dispatch is specified by the \c Transform /// template parameter, which defaults to <tt>tag_of\<_\>()</tt>. /// That is, when the \c Trannsform is not specified, the alternate /// grammar is looked up using the tag type of the current expression. /// /// When used as a transform, \c switch_\<\> applies the transform /// associated with the grammar that matches the expression. /// /// \note \c switch_\<\> is functionally identical to \c or_\<\> but /// is often more efficient. It does a fast, O(1) lookup using the /// result of the specified transform to find a sub-grammar that may /// potentially match the expression. /// /// An expression type \c E matches <tt>switch_\<C,T\></tt> if \c E /// matches <tt>C::case_\<boost::result_of\<T(E)\>::type\></tt>. /// /// When applying <tt>switch_\<C,T\></tt> as a transform with an /// expression \c e of type \c E, state \c s of type \S and data /// \c d of type \c D, it is equivalent to /// <tt>C::case_\<boost::result_of\<T(E,S,D)\>::type\>()(e, s, d)</tt>. template<typename Cases, typename Transform> struct switch_ : transform<switch_<Cases, Transform> > { typedef switch_ proto_grammar; template<typename Expr, typename State, typename Data> struct impl : Cases::template case_< typename when<_, Transform>::template impl<Expr, State, Data>::result_type >::template impl<Expr, State, Data> {}; }; /// INTERNAL ONLY (This is merely a compile-time optimization for the common case) /// template<typename Cases> struct switch_<Cases> : transform<switch_<Cases> > { typedef switch_ proto_grammar; template<typename Expr, typename State, typename Data> struct impl : Cases::template case_<typename Expr::proto_tag>::template impl<Expr, State, Data> {}; template<typename Expr, typename State, typename Data> struct impl<Expr &, State, Data> : Cases::template case_<typename Expr::proto_tag>::template impl<Expr &, State, Data> {}; }; /// \brief For forcing exact matches of terminal types. /// /// By default, matching terminals ignores references and /// cv-qualifiers. For instance, a terminal expression of /// type <tt>terminal\<int const &\>::type</tt> will match /// the grammar <tt>terminal\<int\></tt>. If that is not /// desired, you can force an exact match with /// <tt>terminal\<exact\<int\> \></tt>. This will only /// match integer terminals where the terminal is held by /// value. template<typename T> struct exact {}; /// \brief For matching terminals that are convertible to /// a type. /// /// Use \c convertible_to\<\> to match a terminal that is /// convertible to some type. For example, the grammar /// <tt>terminal\<convertible_to\<int\> \></tt> will match /// any terminal whose argument is convertible to an integer. /// /// \note The trait \c is_convertible\<\> from Boost.Type_traits /// is used to determinal convertibility. template<typename T> struct convertible_to {}; /// \brief For matching a Grammar to a variable number of /// sub-expressions. /// /// An expression type <tt>expr\<AT, listN\<A0,...An,U0,...Um\> \></tt> /// matches a grammar <tt>expr\<BT, listM\<B0,...Bn,vararg\<V\> \> \></tt> /// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx /// for each \c x in <tt>[0,n)</tt> and if \c Ux matches \c V /// for each \c x in <tt>[0,m)</tt>. /// /// For example: /// /// \code /// // Match any function call expression, irregardless /// // of the number of function arguments: /// struct Function /// : function< vararg<_> > /// {}; /// \endcode /// /// When used as a transform, <tt>vararg\<G\></tt> applies /// <tt>G</tt>'s transform. template<typename Grammar> struct vararg : Grammar { /// INTERNAL ONLY typedef void proto_is_vararg_; }; /// INTERNAL ONLY /// template<BOOST_PROTO_LOGICAL_typename_G> struct is_callable<or_<BOOST_PROTO_LOGICAL_G> > : mpl::true_ {}; /// INTERNAL ONLY /// template<BOOST_PROTO_LOGICAL_typename_G> struct is_callable<and_<BOOST_PROTO_LOGICAL_G> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename Grammar> struct is_callable<not_<Grammar> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename If, typename Then, typename Else> struct is_callable<if_<If, Then, Else> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename Grammar> struct is_callable<vararg<Grammar> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename Cases, typename Transform> struct is_callable<switch_<Cases, Transform> > : mpl::true_ {}; }} #undef BOOST_PROTO_LOGICAL_typename_G #undef BOOST_PROTO_LOGICAL_G #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[y���) �) debug.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file debug.hpp /// Utilities for debugging Proto expression trees // // Copyright 2008 Eric Niebler. 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_PROTO_DEBUG_HPP_EAN_12_31_2006 #define BOOST_PROTO_DEBUG_HPP_EAN_12_31_2006 #include <iostream> #include <boost/preprocessor/stringize.hpp> #include <boost/core/ref.hpp> #include <boost/core/typeinfo.hpp> #include <boost/mpl/assert.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/matches.hpp> #include <boost/proto/fusion.hpp> #include <boost/fusion/algorithm/iteration/for_each.hpp> namespace boost { namespace proto { namespace tagns_ { namespace tag { #define BOOST_PROTO_DEFINE_TAG_INSERTION(Tag) \ /** \brief INTERNAL ONLY */ \ inline std::ostream &operator <<(std::ostream &sout, Tag const &) \ { \ return sout << BOOST_PP_STRINGIZE(Tag); \ } \ /**/ BOOST_PROTO_DEFINE_TAG_INSERTION(terminal) BOOST_PROTO_DEFINE_TAG_INSERTION(unary_plus) BOOST_PROTO_DEFINE_TAG_INSERTION(negate) BOOST_PROTO_DEFINE_TAG_INSERTION(dereference) BOOST_PROTO_DEFINE_TAG_INSERTION(complement) BOOST_PROTO_DEFINE_TAG_INSERTION(address_of) BOOST_PROTO_DEFINE_TAG_INSERTION(logical_not) BOOST_PROTO_DEFINE_TAG_INSERTION(pre_inc) BOOST_PROTO_DEFINE_TAG_INSERTION(pre_dec) BOOST_PROTO_DEFINE_TAG_INSERTION(post_inc) BOOST_PROTO_DEFINE_TAG_INSERTION(post_dec) BOOST_PROTO_DEFINE_TAG_INSERTION(shift_left) BOOST_PROTO_DEFINE_TAG_INSERTION(shift_right) BOOST_PROTO_DEFINE_TAG_INSERTION(multiplies) BOOST_PROTO_DEFINE_TAG_INSERTION(divides) BOOST_PROTO_DEFINE_TAG_INSERTION(modulus) BOOST_PROTO_DEFINE_TAG_INSERTION(plus) BOOST_PROTO_DEFINE_TAG_INSERTION(minus) BOOST_PROTO_DEFINE_TAG_INSERTION(less) BOOST_PROTO_DEFINE_TAG_INSERTION(greater) BOOST_PROTO_DEFINE_TAG_INSERTION(less_equal) BOOST_PROTO_DEFINE_TAG_INSERTION(greater_equal) BOOST_PROTO_DEFINE_TAG_INSERTION(equal_to) BOOST_PROTO_DEFINE_TAG_INSERTION(not_equal_to) BOOST_PROTO_DEFINE_TAG_INSERTION(logical_or) BOOST_PROTO_DEFINE_TAG_INSERTION(logical_and) BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_and) BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_or) BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_xor) BOOST_PROTO_DEFINE_TAG_INSERTION(comma) BOOST_PROTO_DEFINE_TAG_INSERTION(mem_ptr) BOOST_PROTO_DEFINE_TAG_INSERTION(assign) BOOST_PROTO_DEFINE_TAG_INSERTION(shift_left_assign) BOOST_PROTO_DEFINE_TAG_INSERTION(shift_right_assign) BOOST_PROTO_DEFINE_TAG_INSERTION(multiplies_assign) BOOST_PROTO_DEFINE_TAG_INSERTION(divides_assign) BOOST_PROTO_DEFINE_TAG_INSERTION(modulus_assign) BOOST_PROTO_DEFINE_TAG_INSERTION(plus_assign) BOOST_PROTO_DEFINE_TAG_INSERTION(minus_assign) BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_and_assign) BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_or_assign) BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_xor_assign) BOOST_PROTO_DEFINE_TAG_INSERTION(subscript) BOOST_PROTO_DEFINE_TAG_INSERTION(member) BOOST_PROTO_DEFINE_TAG_INSERTION(if_else_) BOOST_PROTO_DEFINE_TAG_INSERTION(function) #undef BOOST_PROTO_DEFINE_TAG_INSERTION }} namespace hidden_detail_ { struct ostream_wrapper { ostream_wrapper(std::ostream &sout) : sout_(sout) {} std::ostream &sout_; BOOST_DELETED_FUNCTION(ostream_wrapper &operator =(ostream_wrapper const &)) }; struct named_any { template<typename T> named_any(T const &) : name_(BOOST_CORE_TYPEID(T).name()) {} char const *name_; }; inline std::ostream &operator <<(ostream_wrapper sout_wrap, named_any t) { return sout_wrap.sout_ << t.name_; } } namespace detail { // copyable functor to pass by value to fusion::foreach struct display_expr_impl; struct display_expr_impl_functor { display_expr_impl_functor(display_expr_impl const& impl): impl_(impl) {} template<typename Expr> void operator()(Expr const &expr) const { this->impl_(expr); } private: display_expr_impl const& impl_; }; struct display_expr_impl { explicit display_expr_impl(std::ostream &sout, int depth = 0) : depth_(depth) , first_(true) , sout_(sout) {} template<typename Expr> void operator()(Expr const &expr) const { this->impl(expr, mpl::long_<arity_of<Expr>::value>()); } BOOST_DELETED_FUNCTION(display_expr_impl(display_expr_impl const &)) BOOST_DELETED_FUNCTION(display_expr_impl &operator =(display_expr_impl const &)) private: template<typename Expr> void impl(Expr const &expr, mpl::long_<0>) const { using namespace hidden_detail_; typedef typename tag_of<Expr>::type tag; this->sout_.width(this->depth_); this->sout_ << (this->first_? "" : ", "); this->sout_ << tag() << "(" << proto::value(expr) << ")\n"; this->first_ = false; } template<typename Expr, typename Arity> void impl(Expr const &expr, Arity) const { using namespace hidden_detail_; typedef typename tag_of<Expr>::type tag; this->sout_.width(this->depth_); this->sout_ << (this->first_? "" : ", "); this->sout_ << tag() << "(\n"; display_expr_impl display(this->sout_, this->depth_ + 4); fusion::for_each(expr, display_expr_impl_functor(display)); this->sout_.width(this->depth_); this->sout_ << "" << ")\n"; this->first_ = false; } int depth_; mutable bool first_; std::ostream &sout_; }; } namespace functional { /// \brief Pretty-print a Proto expression tree. /// /// A PolymorphicFunctionObject which accepts a Proto expression /// tree and pretty-prints it to an \c ostream for debugging /// purposes. struct display_expr { BOOST_PROTO_CALLABLE() typedef void result_type; /// \param sout The \c ostream to which the expression tree /// will be written. /// \param depth The starting indentation depth for this node. /// Children nodes will be displayed at a starting /// depth of <tt>depth+4</tt>. explicit display_expr(std::ostream &sout = std::cout, int depth = 0) : depth_(depth) , sout_(sout) {} /// \brief Pretty-print the current node in a Proto expression /// tree. template<typename Expr> void operator()(Expr const &expr) const { detail::display_expr_impl(this->sout_, this->depth_)(expr); } private: int depth_; reference_wrapper<std::ostream> sout_; }; } /// \brief Pretty-print a Proto expression tree. /// /// \note Equivalent to <tt>functional::display_expr(0, sout)(expr)</tt> /// \param expr The Proto expression tree to pretty-print /// \param sout The \c ostream to which the output should be /// written. If not specified, defaults to /// <tt>std::cout</tt>. template<typename Expr> void display_expr(Expr const &expr, std::ostream &sout) { functional::display_expr(sout, 0)(expr); } /// \overload /// template<typename Expr> void display_expr(Expr const &expr) { functional::display_expr()(expr); } /// \brief Assert at compile time that a particular expression /// matches the specified grammar. /// /// \note Equivalent to <tt>BOOST_MPL_ASSERT((proto::matches\<Expr, Grammar\>))</tt> /// \param expr The Proto expression to check againts <tt>Grammar</tt> template<typename Grammar, typename Expr> void assert_matches(Expr const & /*expr*/) { BOOST_MPL_ASSERT((proto::matches<Expr, Grammar>)); } /// \brief Assert at compile time that a particular expression /// does not match the specified grammar. /// /// \note Equivalent to <tt>BOOST_MPL_ASSERT_NOT((proto::matches\<Expr, Grammar\>))</tt> /// \param expr The Proto expression to check againts <tt>Grammar</tt> template<typename Grammar, typename Expr> void assert_matches_not(Expr const & /*expr*/) { BOOST_MPL_ASSERT_NOT((proto::matches<Expr, Grammar>)); } /// \brief Assert at compile time that a particular expression /// matches the specified grammar. /// /// \note Equivalent to <tt>proto::assert_matches\<Grammar\>(Expr)</tt> /// \param Expr The Proto expression to check againts <tt>Grammar</tt> /// \param Grammar The grammar used to validate Expr. #define BOOST_PROTO_ASSERT_MATCHES(Expr, Grammar) \ (true ? (void)0 : boost::proto::assert_matches<Grammar>(Expr)) /// \brief Assert at compile time that a particular expression /// does not match the specified grammar. /// /// \note Equivalent to <tt>proto::assert_matches_not\<Grammar\>(Expr)</tt> /// \param Expr The Proto expression to check againts <tt>Grammar</tt> /// \param Grammar The grammar used to validate Expr. #define BOOST_PROTO_ASSERT_MATCHES_NOT(Expr, Grammar) \ (true ? (void)0 : boost::proto::assert_matches_not<Grammar>(Expr)) }} #endif PK �J�[�/I deep_copy.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file deep_copy.hpp /// Replace all nodes stored by reference by nodes stored by value. // // Copyright 2008 Eric Niebler. 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_PROTO_DEEP_COPY_HPP_EAN_11_21_2006 #define BOOST_PROTO_DEEP_COPY_HPP_EAN_11_21_2006 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/mpl/if.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/args.hpp> #include <boost/proto/expr.hpp> namespace boost { namespace proto { namespace detail { template<typename Expr, long Arity = Expr::proto_arity_c> struct deep_copy_impl; template<typename Expr> struct deep_copy_impl<Expr, 0> { typedef typename base_expr< typename Expr::proto_domain , tag::terminal , term<typename term_traits<typename Expr::proto_child0>::value_type> >::type expr_type; typedef typename Expr::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; template<typename Expr2, typename S, typename D> result_type operator()(Expr2 const &e, S const &, D const &) const { return proto_generator()(expr_type::make(e.proto_base().child0)); } }; } namespace result_of { /// \brief A metafunction for calculating the return type /// of \c proto::deep_copy(). /// /// A metafunction for calculating the return type /// of \c proto::deep_copy(). The type parameter \c Expr /// should be the type of a Proto expression tree. /// It should not be a reference type, nor should it /// be cv-qualified. template<typename Expr> struct deep_copy { typedef typename detail::deep_copy_impl< BOOST_PROTO_UNCVREF(Expr) >::result_type type; }; } namespace functional { /// \brief A PolymorphicFunctionObject type for deep-copying /// Proto expression trees. /// /// A PolymorphicFunctionObject type for deep-copying /// Proto expression trees. When a tree is deep-copied, /// all internal nodes and most terminals held by reference /// are instead held by value. /// /// \attention Terminals of reference-to-function type are /// left unchanged. Terminals of reference-to-array type are /// stored by value, which can cause a large amount of data /// to be passed by value and stored on the stack. struct deep_copy { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Expr> struct result<This(Expr)> { typedef typename detail::deep_copy_impl< BOOST_PROTO_UNCVREF(Expr) >::result_type type; }; /// \brief Deep-copies a Proto expression tree, turning all /// nodes and terminals held by reference into ones held by /// value. template<typename Expr> typename result_of::deep_copy<Expr>::type operator()(Expr const &e) const { return proto::detail::deep_copy_impl<Expr>()(e, 0, 0); } }; } /// \brief A function for deep-copying /// Proto expression trees. /// /// A function for deep-copying /// Proto expression trees. When a tree is deep-copied, /// all internal nodes and most terminals held by reference /// are instead held by value. /// /// \attention Terminals of reference-to-function type are /// left unchanged. /// /// \sa proto::functional::deep_copy. template<typename Expr> typename proto::result_of::deep_copy<Expr>::type deep_copy(Expr const &e) { return proto::detail::deep_copy_impl<Expr>()(e, 0, 0); } /// \brief A PrimitiveTransform for deep-copying /// Proto expression trees. /// /// A PrimitiveTransform for deep-copying /// Proto expression trees. When a tree is deep-copied, /// all internal nodes and most terminals held by reference /// are instead held by value. /// /// \attention Terminals of reference-to-function type are /// left unchanged. /// /// \sa proto::functional::deep_copy. struct _deep_copy : proto::transform<_deep_copy> { template<typename E, typename S, typename D> struct impl : detail::deep_copy_impl<BOOST_PROTO_UNCVREF(E)> {}; }; namespace detail { // include the definition of deep_copy_impl #include <boost/proto/detail/deep_copy.hpp> } }} #endif // BOOST_PROTO_COMPILER_DEEP_COPY_HPP_EAN_11_21_2006 PK �J�[ٜ��Q �Q fusion.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file fusion.hpp /// Make any Proto expression a valid Fusion sequence // // Copyright 2008 Eric Niebler. 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_PROTO_FUSION_HPP_EAN_11_04_2006 #define BOOST_PROTO_FUSION_HPP_EAN_11_04_2006 #include <boost/config.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/long.hpp> #include <boost/mpl/sequence_tag_fwd.hpp> #include <boost/utility/enable_if.hpp> #include <boost/fusion/include/is_view.hpp> #include <boost/fusion/include/tag_of_fwd.hpp> #include <boost/fusion/include/category_of.hpp> #include <boost/fusion/include/iterator_base.hpp> #include <boost/fusion/include/intrinsic.hpp> #include <boost/fusion/include/single_view.hpp> #include <boost/fusion/include/transform.hpp> #include <boost/fusion/include/as_list.hpp> #include <boost/fusion/include/is_segmented.hpp> #include <boost/fusion/sequence/comparison/enable_comparison.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/eval.hpp> #include <boost/proto/make_expr.hpp> #ifdef BOOST_MSVC #pragma warning(push) #pragma warning(disable : 4510) // default constructor could not be generated #pragma warning(disable : 4512) // assignment operator could not be generated #pragma warning(disable : 4610) // can never be instantiated - user defined constructor required #endif namespace boost { namespace proto { namespace detail { template<typename Expr, long Pos> struct expr_iterator : fusion::iterator_base<expr_iterator<Expr, Pos> > { typedef Expr expr_type; static const long index = Pos; typedef fusion::random_access_traversal_tag category; typedef tag::proto_expr_iterator< typename Expr::proto_tag , typename Expr::proto_domain > fusion_tag; explicit expr_iterator(Expr &e) : expr(e) {} Expr &expr; }; template<typename Tag> struct as_element { template<typename Sig> struct result; template<typename This, typename Expr> struct result<This(Expr)> : result<This(Expr const &)> {}; template<typename This, typename Expr> struct result<This(Expr &)> : mpl::if_c< is_same<Tag, typename Expr::proto_tag>::value , flat_view<Expr> , fusion::single_view<Expr &> > {}; template<typename Expr> typename result<as_element(Expr &)>::type const operator ()(Expr &e) const { return typename result<as_element(Expr &)>::type(e); } template<typename Expr> typename result<as_element(Expr const &)>::type const operator ()(Expr const &e) const { return typename result<as_element(Expr const &)>::type(e); } }; template<typename Expr> struct flat_view : fusion::sequence_base<flat_view<Expr> > { typedef fusion::forward_traversal_tag category; typedef tag::proto_flat_view< typename Expr::proto_tag , typename Expr::proto_domain > fusion_tag; typedef typename fusion::result_of::as_list< typename fusion::result_of::transform< Expr , as_element<typename Expr::proto_tag> >::type >::type segments_type; explicit flat_view(Expr &e) : segs_(fusion::as_list(fusion::transform(e, as_element<typename Expr::proto_tag>()))) {} segments_type segs_; }; } namespace result_of { template<typename Expr> struct flatten : flatten<Expr const &> {}; template<typename Expr> struct flatten<Expr &> { typedef detail::flat_view<Expr> type; }; } namespace functional { /// \brief A PolymorphicFunctionObject type that returns a "flattened" /// view of a Proto expression tree. /// /// A PolymorphicFunctionObject type that returns a "flattened" /// view of a Proto expression tree. For a tree with a top-most node /// tag of type \c T, the elements of the flattened sequence are /// determined by recursing into each child node with the same /// tag type and returning those nodes of different type. So for /// instance, the Proto expression tree corresponding to the /// expression <tt>a | b | c</tt> has a flattened view with elements /// [a, b, c], even though the tree is grouped as /// <tt>((a | b) | c)</tt>. struct flatten { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Expr> struct result<This(Expr)> : result<This(Expr const &)> {}; template<typename This, typename Expr> struct result<This(Expr &)> { typedef proto::detail::flat_view<Expr> type; }; template<typename Expr> proto::detail::flat_view<Expr> const operator ()(Expr &e) const { return proto::detail::flat_view<Expr>(e); } template<typename Expr> proto::detail::flat_view<Expr const> const operator ()(Expr const &e) const { return proto::detail::flat_view<Expr const>(e); } }; } /// \brief A function that returns a "flattened" /// view of a Proto expression tree. /// /// For a tree with a top-most node /// tag of type \c T, the elements of the flattened sequence are /// determined by recursing into each child node with the same /// tag type and returning those nodes of different type. So for /// instance, the Proto expression tree corresponding to the /// expression <tt>a | b | c</tt> has a flattened view with elements /// [a, b, c], even though the tree is grouped as /// <tt>((a | b) | c)</tt>. template<typename Expr> proto::detail::flat_view<Expr> const flatten(Expr &e) { return proto::detail::flat_view<Expr>(e); } /// \overload /// template<typename Expr> proto::detail::flat_view<Expr const> const flatten(Expr const &e) { return proto::detail::flat_view<Expr const>(e); } /// INTERNAL ONLY /// template<typename Context> struct eval_fun : proto::callable { explicit eval_fun(Context &ctx) : ctx_(ctx) {} template<typename Sig> struct result; template<typename This, typename Expr> struct result<This(Expr)> : result<This(Expr const &)> {}; template<typename This, typename Expr> struct result<This(Expr &)> : proto::result_of::eval<Expr, Context> {}; template<typename Expr> typename proto::result_of::eval<Expr, Context>::type operator ()(Expr &e) const { return proto::eval(e, this->ctx_); } template<typename Expr> typename proto::result_of::eval<Expr const, Context>::type operator ()(Expr const &e) const { return proto::eval(e, this->ctx_); } private: Context &ctx_; }; /// INTERNAL ONLY /// template<typename Context> struct is_callable<eval_fun<Context> > : mpl::true_ {}; }} namespace boost { namespace fusion { namespace extension { template<typename Tag> struct is_sequence_impl; template<typename Tag, typename Domain> struct is_sequence_impl<proto::tag::proto_flat_view<Tag, Domain> > { template<typename Sequence> struct apply : mpl::true_ {}; }; template<typename Tag, typename Domain> struct is_sequence_impl<proto::tag::proto_expr<Tag, Domain> > { template<typename Sequence> struct apply : mpl::true_ {}; }; template<typename Tag> struct is_view_impl; template<typename Tag, typename Domain> struct is_view_impl<proto::tag::proto_flat_view<Tag, Domain> > { template<typename Sequence> struct apply : mpl::true_ {}; }; template<typename Tag, typename Domain> struct is_view_impl<proto::tag::proto_expr<Tag, Domain> > { template<typename Sequence> struct apply : mpl::false_ {}; }; template<typename Tag> struct value_of_impl; template<typename Tag, typename Domain> struct value_of_impl<proto::tag::proto_expr_iterator<Tag, Domain> > { template< typename Iterator , long Arity = proto::arity_of<typename Iterator::expr_type>::value > struct apply { typedef typename proto::result_of::child_c< typename Iterator::expr_type , Iterator::index >::value_type type; }; template<typename Iterator> struct apply<Iterator, 0> { typedef typename proto::result_of::value< typename Iterator::expr_type >::value_type type; }; }; template<typename Tag> struct deref_impl; template<typename Tag, typename Domain> struct deref_impl<proto::tag::proto_expr_iterator<Tag, Domain> > { template< typename Iterator , long Arity = proto::arity_of<typename Iterator::expr_type>::value > struct apply { typedef typename proto::result_of::child_c< typename Iterator::expr_type & , Iterator::index >::type type; static type call(Iterator const &iter) { return proto::child_c<Iterator::index>(iter.expr); } }; template<typename Iterator> struct apply<Iterator, 0> { typedef typename proto::result_of::value< typename Iterator::expr_type & >::type type; static type call(Iterator const &iter) { return proto::value(iter.expr); } }; }; template<typename Tag> struct advance_impl; template<typename Tag, typename Domain> struct advance_impl<proto::tag::proto_expr_iterator<Tag, Domain> > { template<typename Iterator, typename N> struct apply { typedef proto::detail::expr_iterator< typename Iterator::expr_type , Iterator::index + N::value > type; static type call(Iterator const &iter) { return type(iter.expr); } }; }; template<typename Tag> struct distance_impl; template<typename Tag, typename Domain> struct distance_impl<proto::tag::proto_expr_iterator<Tag, Domain> > { template<typename IteratorFrom, typename IteratorTo> struct apply : mpl::long_<IteratorTo::index - IteratorFrom::index> {}; }; template<typename Tag> struct next_impl; template<typename Tag, typename Domain> struct next_impl<proto::tag::proto_expr_iterator<Tag, Domain> > { template<typename Iterator> struct apply : advance_impl<proto::tag::proto_expr_iterator<Tag, Domain> >::template apply<Iterator, mpl::long_<1> > {}; }; template<typename Tag> struct prior_impl; template<typename Tag, typename Domain> struct prior_impl<proto::tag::proto_expr_iterator<Tag, Domain> > { template<typename Iterator> struct apply : advance_impl<proto::tag::proto_expr_iterator<Tag, Domain> >::template apply<Iterator, mpl::long_<-1> > {}; }; template<typename Tag> struct category_of_impl; template<typename Tag, typename Domain> struct category_of_impl<proto::tag::proto_expr<Tag, Domain> > { template<typename Sequence> struct apply { typedef random_access_traversal_tag type; }; }; template<typename Tag> struct size_impl; template<typename Tag, typename Domain> struct size_impl<proto::tag::proto_expr<Tag, Domain> > { template<typename Sequence> struct apply : mpl::long_<0 == Sequence::proto_arity_c ? 1 : Sequence::proto_arity_c> {}; }; template<typename Tag> struct begin_impl; template<typename Tag, typename Domain> struct begin_impl<proto::tag::proto_expr<Tag, Domain> > { template<typename Sequence> struct apply { typedef proto::detail::expr_iterator<Sequence, 0> type; static type call(Sequence &seq) { return type(seq); } }; }; template<typename Tag> struct end_impl; template<typename Tag, typename Domain> struct end_impl<proto::tag::proto_expr<Tag, Domain> > { template<typename Sequence> struct apply { typedef proto::detail::expr_iterator< Sequence , 0 == Sequence::proto_arity_c ? 1 : Sequence::proto_arity_c > type; static type call(Sequence &seq) { return type(seq); } }; }; template<typename Tag> struct value_at_impl; template<typename Tag, typename Domain> struct value_at_impl<proto::tag::proto_expr<Tag, Domain> > { template< typename Sequence , typename Index , long Arity = proto::arity_of<Sequence>::value > struct apply { typedef typename proto::result_of::child_c< Sequence , Index::value >::value_type type; }; template<typename Sequence, typename Index> struct apply<Sequence, Index, 0> { typedef typename proto::result_of::value< Sequence >::value_type type; }; }; template<typename Tag> struct at_impl; template<typename Tag, typename Domain> struct at_impl<proto::tag::proto_expr<Tag, Domain> > { template< typename Sequence , typename Index , long Arity = proto::arity_of<Sequence>::value > struct apply { typedef typename proto::result_of::child_c< Sequence & , Index::value >::type type; static type call(Sequence &seq) { return proto::child_c<Index::value>(seq); } }; template<typename Sequence, typename Index> struct apply<Sequence, Index, 0> { typedef typename proto::result_of::value< Sequence & >::type type; static type call(Sequence &seq) { return proto::value(seq); } }; }; template<typename Tag> struct convert_impl; template<typename Tag, typename Domain> struct convert_impl<proto::tag::proto_expr<Tag, Domain> > { template<typename Sequence> struct apply { typedef typename proto::result_of::unpack_expr< Tag , Domain , Sequence >::type type; static type call(Sequence& seq) { return proto::unpack_expr<Tag, Domain>(seq); } }; }; template<typename Tag, typename Domain> struct convert_impl<proto::tag::proto_flat_view<Tag, Domain> > { template<typename Sequence> struct apply { typedef typename proto::result_of::unpack_expr< Tag , Domain , Sequence >::type type; static type call(Sequence& seq) { return proto::unpack_expr<Tag, Domain>(seq); } }; }; template<typename Tag> struct is_segmented_impl; template<typename Tag, typename Domain> struct is_segmented_impl<proto::tag::proto_flat_view<Tag, Domain> > { template<typename Iterator> struct apply : mpl::true_ {}; }; template<typename Tag> struct segments_impl; template<typename Tag, typename Domain> struct segments_impl<proto::tag::proto_flat_view<Tag, Domain> > { template<typename Sequence> struct apply { typedef typename Sequence::segments_type const &type; static type call(Sequence &sequence) { return sequence.segs_; } }; }; template<typename Tag, typename Domain> struct category_of_impl<proto::tag::proto_flat_view<Tag, Domain> > { template<typename Sequence> struct apply { typedef forward_traversal_tag type; }; }; } namespace traits { template<typename Seq1, typename Seq2> struct enable_equality< Seq1 , Seq2 , typename enable_if_c< mpl::or_< proto::is_expr<Seq1> , proto::is_expr<Seq2> >::value >::type > : mpl::false_ {}; template<typename Seq1, typename Seq2> struct enable_comparison< Seq1 , Seq2 , typename enable_if_c< mpl::or_< proto::is_expr<Seq1> , proto::is_expr<Seq2> >::value >::type > : mpl::false_ {}; } }} namespace boost { namespace mpl { template<typename Tag, typename Args, long Arity> struct sequence_tag< proto::expr<Tag, Args, Arity> > { typedef fusion::fusion_sequence_tag type; }; template<typename Tag, typename Args, long Arity> struct sequence_tag< proto::basic_expr<Tag, Args, Arity> > { typedef fusion::fusion_sequence_tag type; }; }} #ifdef BOOST_MSVC #pragma warning(pop) #endif #endif PK �J�[�[��L �L context/default.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file default.hpp /// Definintion of default_context, a default evaluation context for /// proto::eval() that uses Boost.Typeof to deduce return types /// of the built-in operators. // // Copyright 2008 Eric Niebler. 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_PROTO_CONTEXT_DEFAULT_HPP_EAN_01_08_2007 #define BOOST_PROTO_CONTEXT_DEFAULT_HPP_EAN_01_08_2007 #include <boost/config.hpp> #include <boost/preprocessor/arithmetic/add.hpp> #include <boost/preprocessor/arithmetic/sub.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/enum_shifted.hpp> #include <boost/utility/result_of.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/type_traits/is_function.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/type_traits/is_member_pointer.hpp> #include <boost/type_traits/is_member_object_pointer.hpp> #include <boost/type_traits/is_member_function_pointer.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/tags.hpp> #include <boost/proto/eval.hpp> #include <boost/proto/traits.hpp> // for proto::child_c() #include <boost/proto/detail/decltype.hpp> namespace boost { namespace proto { /// INTERNAL ONLY /// #define UNREF(x) typename boost::remove_reference<x>::type namespace context { template< typename Expr , typename Context , typename Tag // = typename Expr::proto_tag , long Arity // = Expr::proto_arity_c > struct default_eval {}; template<typename Expr, typename Context> struct default_eval<Expr, Context, tag::terminal, 0> { typedef typename proto::result_of::value<Expr &>::type result_type; result_type operator ()(Expr &expr, Context &) const { return proto::value(expr); } }; /// INTERNAL ONLY /// #define BOOST_PROTO_UNARY_DEFAULT_EVAL(OP, TAG, MAKE) \ template<typename Expr, typename Context> \ struct default_eval<Expr, Context, TAG, 1> \ { \ private: \ typedef typename proto::result_of::child_c<Expr, 0>::type e0; \ typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; \ public: \ BOOST_PROTO_DECLTYPE_(OP proto::detail::MAKE<r0>(), result_type) \ result_type operator ()(Expr &expr, Context &ctx) const \ { \ return OP proto::eval(proto::child_c<0>(expr), ctx); \ } \ }; \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_BINARY_DEFAULT_EVAL(OP, TAG, LMAKE, RMAKE) \ template<typename Expr, typename Context> \ struct default_eval<Expr, Context, TAG, 2> \ { \ private: \ typedef typename proto::result_of::child_c<Expr, 0>::type e0; \ typedef typename proto::result_of::child_c<Expr, 1>::type e1; \ typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; \ typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1; \ public: \ BOOST_PROTO_DECLTYPE_( \ proto::detail::LMAKE<r0>() OP proto::detail::RMAKE<r1>() \ , result_type \ ) \ result_type operator ()(Expr &expr, Context &ctx) const \ { \ return proto::eval( \ proto::child_c<0>(expr), ctx) OP proto::eval(proto::child_c<1>(expr) \ , ctx \ ); \ } \ }; \ /**/ BOOST_PROTO_UNARY_DEFAULT_EVAL(+, proto::tag::unary_plus, make) BOOST_PROTO_UNARY_DEFAULT_EVAL(-, proto::tag::negate, make) BOOST_PROTO_UNARY_DEFAULT_EVAL(*, proto::tag::dereference, make) BOOST_PROTO_UNARY_DEFAULT_EVAL(~, proto::tag::complement, make) BOOST_PROTO_UNARY_DEFAULT_EVAL(&, proto::tag::address_of, make) BOOST_PROTO_UNARY_DEFAULT_EVAL(!, proto::tag::logical_not, make) BOOST_PROTO_UNARY_DEFAULT_EVAL(++, proto::tag::pre_inc, make_mutable) BOOST_PROTO_UNARY_DEFAULT_EVAL(--, proto::tag::pre_dec, make_mutable) BOOST_PROTO_BINARY_DEFAULT_EVAL(<<, proto::tag::shift_left, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(>>, proto::tag::shift_right, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(*, proto::tag::multiplies, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(/, proto::tag::divides, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(%, proto::tag::modulus, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(+, proto::tag::plus, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(-, proto::tag::minus, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(<, proto::tag::less, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(>, proto::tag::greater, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(<=, proto::tag::less_equal, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(>=, proto::tag::greater_equal, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(==, proto::tag::equal_to, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(!=, proto::tag::not_equal_to, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(||, proto::tag::logical_or, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(&&, proto::tag::logical_and, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(&, proto::tag::bitwise_and, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(|, proto::tag::bitwise_or, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(^, proto::tag::bitwise_xor, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(=, proto::tag::assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(<<=, proto::tag::shift_left_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(>>=, proto::tag::shift_right_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(*=, proto::tag::multiplies_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(/=, proto::tag::divides_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(%=, proto::tag::modulus_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(+=, proto::tag::plus_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(-=, proto::tag::minus_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(&=, proto::tag::bitwise_and_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(|=, proto::tag::bitwise_or_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(^=, proto::tag::bitwise_xor_assign, make_mutable, make) #undef BOOST_PROTO_UNARY_DEFAULT_EVAL #undef BOOST_PROTO_BINARY_DEFAULT_EVAL /// INTERNAL ONLY template<typename Expr, typename Context> struct is_member_function_eval : is_member_function_pointer< typename detail::uncvref< typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c<Expr, 1>::type >::type , Context >::type >::type > {}; /// INTERNAL ONLY template<typename Expr, typename Context, bool IsMemFunCall> struct memfun_eval { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1; public: typedef typename detail::mem_ptr_fun<r0, r1>::result_type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return detail::mem_ptr_fun<r0, r1>()( proto::eval(proto::child_c<0>(expr), ctx) , proto::eval(proto::child_c<1>(expr), ctx) ); } }; /// INTERNAL ONLY template<typename Expr, typename Context> struct memfun_eval<Expr, Context, true> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1; public: typedef detail::memfun<r0, r1> result_type; result_type const operator ()(Expr &expr, Context &ctx) const { return detail::memfun<r0, r1>( proto::eval(proto::child_c<0>(expr), ctx) , proto::eval(proto::child_c<1>(expr), ctx) ); } }; template<typename Expr, typename Context> struct default_eval<Expr, Context, tag::mem_ptr, 2> : memfun_eval<Expr, Context, is_member_function_eval<Expr, Context>::value> {}; // Handle post-increment specially. template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::post_inc, 1> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; public: BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() ++, result_type) result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval(proto::child_c<0>(expr), ctx) ++; } }; // Handle post-decrement specially. template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::post_dec, 1> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; public: BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() --, result_type) result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval(proto::child_c<0>(expr), ctx) --; } }; // Handle subscript specially. template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::subscript, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1; public: BOOST_PROTO_DECLTYPE_(proto::detail::make_subscriptable<r0>()[proto::detail::make<r1>()], result_type) result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval(proto::child_c<0>(expr), ctx)[proto::eval(proto::child_c<1>(expr), ctx)]; } }; // Handle if_else_ specially. template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::if_else_, 3> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::child_c<Expr, 2>::type e2; typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1; typedef typename proto::result_of::eval<UNREF(e2), Context>::type r2; public: BOOST_PROTO_DECLTYPE_( proto::detail::make<r0>() ? proto::detail::make<r1>() : proto::detail::make<r2>() , result_type ) result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval(proto::child_c<0>(expr), ctx) ? proto::eval(proto::child_c<1>(expr), ctx) : proto::eval(proto::child_c<2>(expr), ctx); } }; // Handle comma specially. template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::comma, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1; public: typedef typename proto::detail::comma_result<r0, r1>::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval(proto::child_c<0>(expr), ctx), proto::eval(proto::child_c<1>(expr), ctx); } }; // Handle function specially #define BOOST_PROTO_DEFAULT_EVAL_TYPE(Z, N, DATA) \ typename proto::result_of::eval< \ typename remove_reference< \ typename proto::result_of::child_c<DATA, N>::type \ >::type \ , Context \ >::type \ /**/ #define BOOST_PROTO_DEFAULT_EVAL(Z, N, DATA) \ proto::eval(proto::child_c<N>(DATA), context) \ /**/ template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::function, 1> { typedef typename proto::detail::result_of_fixup< BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr) >::type function_type; typedef typename BOOST_PROTO_RESULT_OF<function_type()>::type result_type; result_type operator ()(Expr &expr, Context &context) const { return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)(); } }; template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::function, 2> { typedef typename proto::detail::result_of_fixup< BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr) >::type function_type; typedef typename detail::result_of_< function_type(BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 1, Expr)) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return this->invoke( expr , context , is_member_function_pointer<function_type>() , is_member_object_pointer<function_type>() ); } private: result_type invoke(Expr &expr, Context &context, mpl::false_, mpl::false_) const { return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)(BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)); } result_type invoke(Expr &expr, Context &context, mpl::true_, mpl::false_) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (BOOST_PROTO_DEFAULT_EVAL(~, 1, expr))) ->* BOOST_PROTO_DEFAULT_EVAL(~, 0, expr) )(); } result_type invoke(Expr &expr, Context &context, mpl::false_, mpl::true_) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (BOOST_PROTO_DEFAULT_EVAL(~, 1, expr))) ->* BOOST_PROTO_DEFAULT_EVAL(~, 0, expr) ); } }; // Additional specialization are generated by the preprocessor #include <boost/proto/context/detail/default_eval.hpp> #undef BOOST_PROTO_DEFAULT_EVAL_TYPE #undef BOOST_PROTO_DEFAULT_EVAL /// default_context /// struct default_context { /// default_context::eval /// template<typename Expr, typename ThisContext = default_context const> struct eval : default_eval<Expr, ThisContext> {}; }; } // namespace context }} // namespace boost::proto #undef UNREF #endif PK �J�[G �(+ + context/null.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file null.hpp /// Definintion of null_context\<\>, an evaluation context for /// proto::eval() that simply evaluates each child expression, doesn't /// combine the results at all, and returns void. // // Copyright 2008 Eric Niebler. 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_PROTO_CONTEXT_NULL_HPP_EAN_06_24_2007 #define BOOST_PROTO_CONTEXT_NULL_HPP_EAN_06_24_2007 #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/eval.hpp> #include <boost/proto/traits.hpp> namespace boost { namespace proto { namespace context { template< typename Expr , typename Context , long Arity // = Expr::proto_arity_c > struct null_eval {}; template<typename Expr, typename Context> struct null_eval<Expr, Context, 0> { typedef void result_type; void operator()(Expr &, Context &) const {} }; // Additional specializations generated by the preprocessor #include <boost/proto/context/detail/null_eval.hpp> /// null_context /// struct null_context { /// null_context::eval /// template<typename Expr, typename ThisContext = null_context const> struct eval : null_eval<Expr, ThisContext> {}; }; }}} #endif PK �J�[��`3�W �W - context/detail/preprocessed/callable_eval.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file callable_eval.hpp /// Contains specializations of the callable_eval\<\> class template. // // Copyright 2008 Eric Niebler. 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) namespace detail { template<typename Expr, typename Context> struct is_expr_handled<Expr, Context, 1> { static callable_context_wrapper<Context> &sctx_; static Expr &sexpr_; static typename Expr::proto_tag &stag_; static const bool value = sizeof(yes_type) == sizeof( detail::check_is_expr_handled( (sctx_( stag_ , proto::child_c< 0>( sexpr_) ), 0) ) ); typedef mpl::bool_<value> type; }; } namespace context { template<typename Expr, typename Context> struct callable_eval<Expr, Context, 1> { typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename BOOST_PROTO_RESULT_OF< Context( typename Expr::proto_tag , child0 ) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return context( typename Expr::proto_tag() , proto::child_c< 0>( expr) ); } }; } namespace detail { template<typename Expr, typename Context> struct is_expr_handled<Expr, Context, 2> { static callable_context_wrapper<Context> &sctx_; static Expr &sexpr_; static typename Expr::proto_tag &stag_; static const bool value = sizeof(yes_type) == sizeof( detail::check_is_expr_handled( (sctx_( stag_ , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) ), 0) ) ); typedef mpl::bool_<value> type; }; } namespace context { template<typename Expr, typename Context> struct callable_eval<Expr, Context, 2> { typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename BOOST_PROTO_RESULT_OF< Context( typename Expr::proto_tag , child0 , child1 ) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return context( typename Expr::proto_tag() , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) ); } }; } namespace detail { template<typename Expr, typename Context> struct is_expr_handled<Expr, Context, 3> { static callable_context_wrapper<Context> &sctx_; static Expr &sexpr_; static typename Expr::proto_tag &stag_; static const bool value = sizeof(yes_type) == sizeof( detail::check_is_expr_handled( (sctx_( stag_ , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) ), 0) ) ); typedef mpl::bool_<value> type; }; } namespace context { template<typename Expr, typename Context> struct callable_eval<Expr, Context, 3> { typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename BOOST_PROTO_RESULT_OF< Context( typename Expr::proto_tag , child0 , child1 , child2 ) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return context( typename Expr::proto_tag() , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) ); } }; } namespace detail { template<typename Expr, typename Context> struct is_expr_handled<Expr, Context, 4> { static callable_context_wrapper<Context> &sctx_; static Expr &sexpr_; static typename Expr::proto_tag &stag_; static const bool value = sizeof(yes_type) == sizeof( detail::check_is_expr_handled( (sctx_( stag_ , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) ), 0) ) ); typedef mpl::bool_<value> type; }; } namespace context { template<typename Expr, typename Context> struct callable_eval<Expr, Context, 4> { typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename BOOST_PROTO_RESULT_OF< Context( typename Expr::proto_tag , child0 , child1 , child2 , child3 ) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return context( typename Expr::proto_tag() , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) ); } }; } namespace detail { template<typename Expr, typename Context> struct is_expr_handled<Expr, Context, 5> { static callable_context_wrapper<Context> &sctx_; static Expr &sexpr_; static typename Expr::proto_tag &stag_; static const bool value = sizeof(yes_type) == sizeof( detail::check_is_expr_handled( (sctx_( stag_ , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) ), 0) ) ); typedef mpl::bool_<value> type; }; } namespace context { template<typename Expr, typename Context> struct callable_eval<Expr, Context, 5> { typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename BOOST_PROTO_RESULT_OF< Context( typename Expr::proto_tag , child0 , child1 , child2 , child3 , child4 ) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return context( typename Expr::proto_tag() , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) ); } }; } namespace detail { template<typename Expr, typename Context> struct is_expr_handled<Expr, Context, 6> { static callable_context_wrapper<Context> &sctx_; static Expr &sexpr_; static typename Expr::proto_tag &stag_; static const bool value = sizeof(yes_type) == sizeof( detail::check_is_expr_handled( (sctx_( stag_ , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) ), 0) ) ); typedef mpl::bool_<value> type; }; } namespace context { template<typename Expr, typename Context> struct callable_eval<Expr, Context, 6> { typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename BOOST_PROTO_RESULT_OF< Context( typename Expr::proto_tag , child0 , child1 , child2 , child3 , child4 , child5 ) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return context( typename Expr::proto_tag() , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) ); } }; } namespace detail { template<typename Expr, typename Context> struct is_expr_handled<Expr, Context, 7> { static callable_context_wrapper<Context> &sctx_; static Expr &sexpr_; static typename Expr::proto_tag &stag_; static const bool value = sizeof(yes_type) == sizeof( detail::check_is_expr_handled( (sctx_( stag_ , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) ), 0) ) ); typedef mpl::bool_<value> type; }; } namespace context { template<typename Expr, typename Context> struct callable_eval<Expr, Context, 7> { typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename BOOST_PROTO_RESULT_OF< Context( typename Expr::proto_tag , child0 , child1 , child2 , child3 , child4 , child5 , child6 ) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return context( typename Expr::proto_tag() , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) ); } }; } namespace detail { template<typename Expr, typename Context> struct is_expr_handled<Expr, Context, 8> { static callable_context_wrapper<Context> &sctx_; static Expr &sexpr_; static typename Expr::proto_tag &stag_; static const bool value = sizeof(yes_type) == sizeof( detail::check_is_expr_handled( (sctx_( stag_ , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_) ), 0) ) ); typedef mpl::bool_<value> type; }; } namespace context { template<typename Expr, typename Context> struct callable_eval<Expr, Context, 8> { typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7; typedef typename BOOST_PROTO_RESULT_OF< Context( typename Expr::proto_tag , child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7 ) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return context( typename Expr::proto_tag() , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr) ); } }; } namespace detail { template<typename Expr, typename Context> struct is_expr_handled<Expr, Context, 9> { static callable_context_wrapper<Context> &sctx_; static Expr &sexpr_; static typename Expr::proto_tag &stag_; static const bool value = sizeof(yes_type) == sizeof( detail::check_is_expr_handled( (sctx_( stag_ , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_) , proto::child_c< 8>( sexpr_) ), 0) ) ); typedef mpl::bool_<value> type; }; } namespace context { template<typename Expr, typename Context> struct callable_eval<Expr, Context, 9> { typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7; typedef typename proto::result_of::child_c< Expr const &, 8>::type child8; typedef typename BOOST_PROTO_RESULT_OF< Context( typename Expr::proto_tag , child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 ) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return context( typename Expr::proto_tag() , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr) , proto::child_c< 8>( expr) ); } }; } namespace detail { template<typename Expr, typename Context> struct is_expr_handled<Expr, Context, 10> { static callable_context_wrapper<Context> &sctx_; static Expr &sexpr_; static typename Expr::proto_tag &stag_; static const bool value = sizeof(yes_type) == sizeof( detail::check_is_expr_handled( (sctx_( stag_ , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_) , proto::child_c< 8>( sexpr_) , proto::child_c< 9>( sexpr_) ), 0) ) ); typedef mpl::bool_<value> type; }; } namespace context { template<typename Expr, typename Context> struct callable_eval<Expr, Context, 10> { typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7; typedef typename proto::result_of::child_c< Expr const &, 8>::type child8; typedef typename proto::result_of::child_c< Expr const &, 9>::type child9; typedef typename BOOST_PROTO_RESULT_OF< Context( typename Expr::proto_tag , child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9 ) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return context( typename Expr::proto_tag() , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr) , proto::child_c< 8>( expr) , proto::child_c< 9>( expr) ); } }; } PK �J�[_yf�S S , context/detail/preprocessed/default_eval.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file default_eval.hpp /// Contains specializations of the default_eval\<\> class template. // // Copyright 2008 Eric Niebler. 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) template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::function, 3> { typedef typename proto::detail::result_of_fixup< typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type >::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return this->invoke(expr, context, is_member_function_pointer<function_type>()); } private: result_type invoke(Expr &expr, Context &context, mpl::false_) const { return proto::eval(proto::child_c< 0>( expr), context)( proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) ); } result_type invoke(Expr &expr, Context &context, mpl::true_) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* proto::eval(proto::child_c< 0>( expr), context) )(proto::eval(proto::child_c< 2>( expr), context)); } }; template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::function, 4> { typedef typename proto::detail::result_of_fixup< typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type >::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return this->invoke(expr, context, is_member_function_pointer<function_type>()); } private: result_type invoke(Expr &expr, Context &context, mpl::false_) const { return proto::eval(proto::child_c< 0>( expr), context)( proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) ); } result_type invoke(Expr &expr, Context &context, mpl::true_) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* proto::eval(proto::child_c< 0>( expr), context) )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context)); } }; template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::function, 5> { typedef typename proto::detail::result_of_fixup< typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type >::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return this->invoke(expr, context, is_member_function_pointer<function_type>()); } private: result_type invoke(Expr &expr, Context &context, mpl::false_) const { return proto::eval(proto::child_c< 0>( expr), context)( proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) ); } result_type invoke(Expr &expr, Context &context, mpl::true_) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* proto::eval(proto::child_c< 0>( expr), context) )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context)); } }; template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::function, 6> { typedef typename proto::detail::result_of_fixup< typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type >::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return this->invoke(expr, context, is_member_function_pointer<function_type>()); } private: result_type invoke(Expr &expr, Context &context, mpl::false_) const { return proto::eval(proto::child_c< 0>( expr), context)( proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) ); } result_type invoke(Expr &expr, Context &context, mpl::true_) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* proto::eval(proto::child_c< 0>( expr), context) )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context)); } }; template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::function, 7> { typedef typename proto::detail::result_of_fixup< typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type >::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return this->invoke(expr, context, is_member_function_pointer<function_type>()); } private: result_type invoke(Expr &expr, Context &context, mpl::false_) const { return proto::eval(proto::child_c< 0>( expr), context)( proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) ); } result_type invoke(Expr &expr, Context &context, mpl::true_) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* proto::eval(proto::child_c< 0>( expr), context) )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context)); } }; template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::function, 8> { typedef typename proto::detail::result_of_fixup< typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type >::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return this->invoke(expr, context, is_member_function_pointer<function_type>()); } private: result_type invoke(Expr &expr, Context &context, mpl::false_) const { return proto::eval(proto::child_c< 0>( expr), context)( proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) ); } result_type invoke(Expr &expr, Context &context, mpl::true_) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* proto::eval(proto::child_c< 0>( expr), context) )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context)); } }; template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::function, 9> { typedef typename proto::detail::result_of_fixup< typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type >::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 8>::type >::type , Context >::type) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return this->invoke(expr, context, is_member_function_pointer<function_type>()); } private: result_type invoke(Expr &expr, Context &context, mpl::false_) const { return proto::eval(proto::child_c< 0>( expr), context)( proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context) ); } result_type invoke(Expr &expr, Context &context, mpl::true_) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* proto::eval(proto::child_c< 0>( expr), context) )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context)); } }; template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::function, 10> { typedef typename proto::detail::result_of_fixup< typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type >::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 8>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 9>::type >::type , Context >::type) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return this->invoke(expr, context, is_member_function_pointer<function_type>()); } private: result_type invoke(Expr &expr, Context &context, mpl::false_) const { return proto::eval(proto::child_c< 0>( expr), context)( proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context) , proto::eval(proto::child_c< 9>( expr), context) ); } result_type invoke(Expr &expr, Context &context, mpl::true_) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* proto::eval(proto::child_c< 0>( expr), context) )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context) , proto::eval(proto::child_c< 9>( expr), context)); } }; PK �J�[�!�� � ) context/detail/preprocessed/null_eval.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file null_eval.hpp /// Contains specializations of the null_eval\<\> class template. // // Copyright 2008 Eric Niebler. 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) template<typename Expr, typename Context> struct null_eval<Expr, Context, 1> { typedef void result_type; void operator ()(Expr &expr, Context &ctx) const { proto::eval(proto::child_c< 0>(expr), ctx); } }; template<typename Expr, typename Context> struct null_eval<Expr, Context, 2> { typedef void result_type; void operator ()(Expr &expr, Context &ctx) const { proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); } }; template<typename Expr, typename Context> struct null_eval<Expr, Context, 3> { typedef void result_type; void operator ()(Expr &expr, Context &ctx) const { proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); } }; template<typename Expr, typename Context> struct null_eval<Expr, Context, 4> { typedef void result_type; void operator ()(Expr &expr, Context &ctx) const { proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); } }; template<typename Expr, typename Context> struct null_eval<Expr, Context, 5> { typedef void result_type; void operator ()(Expr &expr, Context &ctx) const { proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); } }; template<typename Expr, typename Context> struct null_eval<Expr, Context, 6> { typedef void result_type; void operator ()(Expr &expr, Context &ctx) const { proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); } }; template<typename Expr, typename Context> struct null_eval<Expr, Context, 7> { typedef void result_type; void operator ()(Expr &expr, Context &ctx) const { proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); } }; template<typename Expr, typename Context> struct null_eval<Expr, Context, 8> { typedef void result_type; void operator ()(Expr &expr, Context &ctx) const { proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx); } }; template<typename Expr, typename Context> struct null_eval<Expr, Context, 9> { typedef void result_type; void operator ()(Expr &expr, Context &ctx) const { proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx); proto::eval(proto::child_c< 8>(expr), ctx); } }; template<typename Expr, typename Context> struct null_eval<Expr, Context, 10> { typedef void result_type; void operator ()(Expr &expr, Context &ctx) const { proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx); proto::eval(proto::child_c< 8>(expr), ctx); proto::eval(proto::child_c< 9>(expr), ctx); } }; PK �J�[Lk��� � context/detail/callable_eval.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/context/detail/preprocessed/callable_eval.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_CHILD_N_TYPE(Z, N, Expr) \ typedef typename proto::result_of::child_c<Expr const &, N>::type BOOST_PP_CAT(child, N); \ /**/ #define BOOST_PROTO_CHILD_N(Z, N, expr) \ proto::child_c<N>(expr) \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/callable_eval.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file callable_eval.hpp /// Contains specializations of the callable_eval\<\> class template. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/context/detail/callable_eval.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_CHILD_N_TYPE #undef BOOST_PROTO_CHILD_N #else #define N BOOST_PP_ITERATION() namespace detail { template<typename Expr, typename Context> struct is_expr_handled<Expr, Context, N> { static callable_context_wrapper<Context> &sctx_; static Expr &sexpr_; static typename Expr::proto_tag &stag_; static const bool value = sizeof(yes_type) == sizeof( detail::check_is_expr_handled( (sctx_( stag_ BOOST_PP_ENUM_TRAILING(N, BOOST_PROTO_CHILD_N, sexpr_) ), 0) ) ); typedef mpl::bool_<value> type; }; } namespace context { /// \brief A BinaryFunction that accepts a Proto expression and a /// callable context and calls the context with the expression tag /// and children as arguments, effectively fanning the expression /// out. /// /// <tt>callable_eval\<\></tt> requires that \c Context is a /// PolymorphicFunctionObject that can be invoked with \c Expr's /// tag and children as expressions, as follows: /// /// \code /// context(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr), ...) /// \endcode template<typename Expr, typename Context> struct callable_eval<Expr, Context, N> { BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD_N_TYPE, Expr) typedef typename BOOST_PROTO_RESULT_OF< Context( typename Expr::proto_tag BOOST_PP_ENUM_TRAILING_PARAMS(N, child) ) >::type result_type; /// \param expr The current expression /// \param context The callable evaluation context /// \return <tt>context(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr), ...)</tt> result_type operator ()(Expr &expr, Context &context) const { return context( typename Expr::proto_tag() BOOST_PP_ENUM_TRAILING(N, BOOST_PROTO_CHILD_N, expr) ); } }; } #undef N #endif PK �J�[�A`}� � context/detail/default_eval.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/context/detail/preprocessed/default_eval.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_DEFAULT_EVAL_SHIFTED(Z, M, DATA) \ BOOST_PROTO_DEFAULT_EVAL(Z, BOOST_PP_ADD(M, 2), DATA) \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/default_eval.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file default_eval.hpp /// Contains specializations of the default_eval\<\> class template. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (3, BOOST_PROTO_MAX_ARITY, <boost/proto/context/detail/default_eval.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_DEFAULT_EVAL_SHIFTED #else #define N BOOST_PP_ITERATION() template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::function, N> { typedef typename proto::detail::result_of_fixup< BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr) >::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL_TYPE, Expr)) >::type result_type; result_type operator ()(Expr &expr, Context &context) const { return this->invoke(expr, context, is_member_function_pointer<function_type>()); } private: result_type invoke(Expr &expr, Context &context, mpl::false_) const { return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)( BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL, expr) ); } result_type invoke(Expr &expr, Context &context, mpl::true_) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (BOOST_PROTO_DEFAULT_EVAL(~, 1, expr))) ->* BOOST_PROTO_DEFAULT_EVAL(~, 0, expr) )(BOOST_PP_ENUM(BOOST_PP_SUB(N, 2), BOOST_PROTO_DEFAULT_EVAL_SHIFTED, expr)); } }; #undef N #endif PK �J�[ - � � context/detail/null_eval.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/context/detail/preprocessed/null_eval.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_EVAL_N(Z, N, DATA) \ proto::eval(proto::child_c<N>(expr), ctx); \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/null_eval.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file null_eval.hpp /// Contains specializations of the null_eval\<\> class template. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/context/detail/null_eval.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_EVAL_N #else #define N BOOST_PP_ITERATION() template<typename Expr, typename Context> struct null_eval<Expr, Context, N> { typedef void result_type; void operator ()(Expr &expr, Context &ctx) const { BOOST_PP_REPEAT(N, BOOST_PROTO_EVAL_N, ~) } }; #undef N #endif PK �J�[8%��.# .# context/callable.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file callable.hpp /// Definintion of callable_context\<\>, an evaluation context for /// proto::eval() that explodes each node and calls the derived context /// type with the expressions constituents. If the derived context doesn't /// have an overload that handles this node, fall back to some other /// context. // // Copyright 2008 Eric Niebler. 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_PROTO_CONTEXT_CALLABLE_HPP_EAN_06_23_2007 #define BOOST_PROTO_CONTEXT_CALLABLE_HPP_EAN_06_23_2007 #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_trailing.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/arithmetic/inc.hpp> #include <boost/preprocessor/selection/max.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/bool.hpp> #include <boost/utility/result_of.hpp> #include <boost/type_traits/remove_cv.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> // for child_c namespace boost { namespace proto { namespace detail { template<typename Context> struct callable_context_wrapper : remove_cv<Context>::type { callable_context_wrapper(); typedef private_type_ fun_type(...); operator fun_type *() const; BOOST_DELETED_FUNCTION(callable_context_wrapper &operator =(callable_context_wrapper const &)) }; template<typename T> yes_type check_is_expr_handled(T const &); no_type check_is_expr_handled(private_type_ const &); template<typename Expr, typename Context, long Arity = Expr::proto_arity_c> struct is_expr_handled; template<typename Expr, typename Context> struct is_expr_handled<Expr, Context, 0> { static callable_context_wrapper<Context> &sctx_; static Expr &sexpr_; static typename Expr::proto_tag &stag_; static const bool value = sizeof(yes_type) == sizeof( detail::check_is_expr_handled( (sctx_(stag_, proto::value(sexpr_)), 0) ) ); typedef mpl::bool_<value> type; }; } namespace context { /// \brief A BinaryFunction that accepts a Proto expression and a /// callable context and calls the context with the expression tag /// and children as arguments, effectively fanning the expression /// out. /// /// <tt>callable_eval\<\></tt> requires that \c Context is a /// PolymorphicFunctionObject that can be invoked with \c Expr's /// tag and children as expressions, as follows: /// /// \code /// context(Expr::proto_tag(), child_c<0>(expr), child_c<1>(expr), ...) /// \endcode template< typename Expr , typename Context , long Arity // = Expr::proto_arity_c > struct callable_eval {}; /// \brief A BinaryFunction that accepts a Proto expression and a /// callable context and calls the context with the expression tag /// and children as arguments, effectively fanning the expression /// out. /// /// <tt>callable_eval\<\></tt> requires that \c Context is a /// PolymorphicFunctionObject that can be invoked with \c Expr's /// tag and children as expressions, as follows: /// /// \code /// context(Expr::proto_tag(), value(expr)) /// \endcode template<typename Expr, typename Context> struct callable_eval<Expr, Context, 0> { typedef typename proto::result_of::value<Expr const &>::type value_type; typedef typename BOOST_PROTO_RESULT_OF< Context(typename Expr::proto_tag, value_type) >::type result_type; /// \param expr The current expression /// \param context The callable evaluation context /// \return <tt>context(Expr::proto_tag(), value(expr))</tt> result_type operator ()(Expr &expr, Context &context) const { return context(typename Expr::proto_tag(), proto::value(expr)); } }; /// \brief An evaluation context adaptor that makes authoring a /// context a simple matter of writing function overloads, rather /// then writing template specializations. /// /// <tt>callable_context\<\></tt> is a base class that implements /// the context protocol by passing fanned-out expression nodes to /// the derived context, making it easy to customize the handling /// of expression types by writing function overloads. Only those /// expression types needing special handling require explicit /// handling. All others are dispatched to a user-specified /// default context, \c DefaultCtx. /// /// <tt>callable_context\<\></tt> is defined simply as: /// /// \code /// template<typename Context, typename DefaultCtx = default_context> /// struct callable_context /// { /// template<typename Expr, typename ThisContext = Context> /// struct eval /// : mpl::if_< /// is_expr_handled_<Expr, Context> // For exposition /// , callable_eval<Expr, ThisContext> /// , typename DefaultCtx::template eval<Expr, Context> /// >::type /// {}; /// }; /// \endcode /// /// The Boolean metafunction <tt>is_expr_handled_\<\></tt> uses /// metaprogramming tricks to determine whether \c Context has /// an overloaded function call operator that accepts the /// fanned-out constituents of an expression of type \c Expr. /// If so, the handling of the expression is dispatched to /// <tt>callable_eval\<\></tt>. If not, it is dispatched to /// the user-specified \c DefaultCtx. /// /// Below is an example of how to use <tt>callable_context\<\></tt>: /// /// \code /// // An evaluation context that increments all /// // integer terminals in-place. /// struct increment_ints /// : callable_context< /// increment_ints const // derived context /// , null_context const // fall-back context /// > /// { /// typedef void result_type; /// /// // Handle int terminals here: /// void operator()(proto::tag::terminal, int &i) const /// { /// ++i; /// } /// }; /// \endcode /// /// With \c increment_ints, we can do the following: /// /// \code /// literal<int> i = 0, j = 10; /// proto::eval( i - j * 3.14, increment_ints() ); /// /// assert( i.get() == 1 && j.get() == 11 ); /// \endcode template< typename Context , typename DefaultCtx // = default_context > struct callable_context { /// A BinaryFunction that accepts an \c Expr and a /// \c Context, and either fans out the expression and passes /// it to the context, or else hands off the expression to /// \c DefaultCtx. /// /// If \c Context is a PolymorphicFunctionObject such that /// it can be invoked with the tag and children of \c Expr, /// as <tt>ctx(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr)...)</tt>, /// then <tt>eval\<Expr, ThisContext\></tt> inherits from /// <tt>callable_eval\<Expr, ThisContext\></tt>. Otherwise, /// <tt>eval\<Expr, ThisContext\></tt> inherits from /// <tt>DefaultCtx::eval\<Expr, Context\></tt>. template<typename Expr, typename ThisContext = Context> struct eval : mpl::if_c< detail::is_expr_handled<Expr, Context>::value , callable_eval<Expr, ThisContext> , typename DefaultCtx::template eval<Expr, Context> >::type {}; }; } #include <boost/proto/context/detail/callable_eval.hpp> }} #endif PK �J�[y g �d �d operators.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file operators.hpp /// Contains all the overloaded operators that make it possible to build /// Proto expression trees. // // Copyright 2008 Eric Niebler. 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_PROTO_OPERATORS_HPP_EAN_04_01_2005 #define BOOST_PROTO_OPERATORS_HPP_EAN_04_01_2005 #include <boost/config.hpp> #include <boost/preprocessor/punctuation/comma.hpp> #include <boost/mpl/logical.hpp> #include <boost/utility/enable_if.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/tags.hpp> #include <boost/proto/domain.hpp> #include <boost/proto/matches.hpp> #include <boost/proto/generate.hpp> #include <boost/proto/make_expr.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { template<typename MakeExpr, typename Grammar> struct lazy_matches : proto::matches<typename MakeExpr::type, Grammar> {}; template<typename Domain, typename Grammar, typename Trait, typename Tag, typename Arg> struct enable_unary : boost::lazy_enable_if_c< boost::mpl::and_< Trait , lazy_matches<result_of::make_expr<Tag, basic_default_domain, Arg>, Grammar> >::value , result_of::make_expr<Tag, Domain, Arg> > {}; template<typename Domain, typename Trait, typename Tag, typename Arg> struct enable_unary<Domain, proto::_, Trait, Tag, Arg &> : boost::lazy_enable_if_c< Trait::value , result_of::make_expr<Tag, Domain, Arg &> > {}; template<typename Trait, typename Tag, typename Arg> struct enable_unary<deduce_domain, not_a_grammar, Trait, Tag, Arg &> : enable_unary< typename domain_of<Arg>::type , typename domain_of<Arg>::type::proto_grammar , Trait , Tag , Arg & > {}; template<typename Domain, typename Grammar, typename Trait, typename Tag, typename Left, typename Right> struct enable_binary : boost::lazy_enable_if_c< boost::mpl::and_< Trait , lazy_matches<result_of::make_expr<Tag, basic_default_domain, Left, Right>, Grammar> >::value , result_of::make_expr<Tag, Domain, Left, Right> > {}; template<typename Domain, typename Trait, typename Tag, typename Left, typename Right> struct enable_binary<Domain, proto::_, Trait, Tag, Left &, Right &> : boost::lazy_enable_if_c< Trait::value , result_of::make_expr<Tag, Domain, Left &, Right &> > {}; template<typename Trait, typename Tag, typename Left, typename Right> struct enable_binary<deduce_domain, not_a_grammar, Trait, Tag, Left &, Right &> : enable_binary< typename deduce_domain2<Left, Right>::type , typename deduce_domain2<Left, Right>::type::proto_grammar , Trait , Tag , Left & , Right & > {}; } // detail #define BOOST_PROTO_UNARY_OP_IS_POSTFIX_0 #define BOOST_PROTO_UNARY_OP_IS_POSTFIX_1 , int #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES #define BOOST_PROTO_DEFINE_UNARY_OPERATOR(OP, TAG, TRAIT, DOMAIN, POST) \ BOOST_PROTO_PUSH_WARNINGS \ \ template<typename Arg> \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename boost::proto::detail::enable_unary< \ DOMAIN \ , DOMAIN::proto_grammar \ , BOOST_PROTO_APPLY_UNARY_(TRAIT, Arg) \ , TAG \ , Arg & \ >::type const \ operator OP(Arg &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \ { \ return boost::proto::detail::make_expr_<TAG, DOMAIN, Arg &>()(arg); \ } \ \ template<typename Arg> \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename boost::proto::detail::enable_unary< \ DOMAIN \ , DOMAIN::proto_grammar \ , BOOST_PROTO_APPLY_UNARY_(TRAIT, Arg) \ , TAG \ , Arg const & \ >::type const \ operator OP(Arg const &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \ { \ return boost::proto::detail::make_expr_<TAG, DOMAIN, Arg const &>()(arg); \ } \ \ BOOST_PROTO_POP_WARNINGS \ /**/ #define BOOST_PROTO_DEFINE_BINARY_OPERATOR(OP, TAG, TRAIT, DOMAIN) \ BOOST_PROTO_PUSH_WARNINGS \ \ template<typename Left, typename Right> \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename boost::proto::detail::enable_binary< \ DOMAIN \ , DOMAIN::proto_grammar \ , BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \ , TAG \ , Left & \ , Right & \ >::type const \ operator OP(Left &left, Right &right) \ { \ return boost::proto::detail::make_expr_<TAG, DOMAIN, Left &, Right &>()(left, right); \ } \ \ template<typename Left, typename Right> \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename boost::proto::detail::enable_binary< \ DOMAIN \ , DOMAIN::proto_grammar \ , BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \ , TAG \ , Left & \ , Right const & \ >::type const \ operator OP(Left &left, Right const &right) \ { \ return boost::proto::detail::make_expr_<TAG, DOMAIN, Left &, Right const &>()(left, right); \ } \ \ template<typename Left, typename Right> \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename boost::proto::detail::enable_binary< \ DOMAIN \ , DOMAIN::proto_grammar \ , BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \ , TAG \ , Left const & \ , Right & \ >::type const \ operator OP(Left const &left, Right &right) \ { \ return boost::proto::detail::make_expr_<TAG, DOMAIN, Left const &, Right &>()(left, right); \ } \ \ template<typename Left, typename Right> \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename boost::proto::detail::enable_binary< \ DOMAIN \ , DOMAIN::proto_grammar \ , BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \ , TAG \ , Left const & \ , Right const & \ >::type const \ operator OP(Left const &left, Right const &right) \ { \ return boost::proto::detail::make_expr_<TAG, DOMAIN, Left const &, Right const &>()(left, right);\ } \ \ BOOST_PROTO_POP_WARNINGS \ /**/ #else #define BOOST_PROTO_DEFINE_UNARY_OPERATOR(OP, TAG, TRAIT, DOMAIN, POST) \ template<typename Arg> \ BOOST_PROTO_PUSH_WARNINGS \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename boost::proto::detail::enable_unary< \ DOMAIN \ , DOMAIN::proto_grammar \ , BOOST_PROTO_APPLY_UNARY_(TRAIT, Arg) \ , TAG \ , Arg const & \ >::type const \ operator OP(Arg &&arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \ { \ return boost::proto::detail::make_expr_<TAG, DOMAIN, Arg const &>()(arg); \ } \ BOOST_PROTO_POP_WARNINGS \ /**/ #define BOOST_PROTO_DEFINE_BINARY_OPERATOR(OP, TAG, TRAIT, DOMAIN) \ template<typename Left, typename Right> \ BOOST_PROTO_PUSH_WARNINGS \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename boost::proto::detail::enable_binary< \ DOMAIN \ , DOMAIN::proto_grammar \ , BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \ , TAG \ , Left const & \ , Right const & \ >::type const \ operator OP(Left &&left, Right &&right) \ { \ return boost::proto::detail::make_expr_<TAG, DOMAIN, Left const &, Right const &>()(left, right);\ } \ BOOST_PROTO_POP_WARNINGS \ /**/ #endif #define BOOST_PROTO_DEFINE_OPERATORS(TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_UNARY_OPERATOR(+, boost::proto::tag::unary_plus, TRAIT, DOMAIN, 0) \ BOOST_PROTO_DEFINE_UNARY_OPERATOR(-, boost::proto::tag::negate, TRAIT, DOMAIN, 0) \ BOOST_PROTO_DEFINE_UNARY_OPERATOR(*, boost::proto::tag::dereference, TRAIT, DOMAIN, 0) \ BOOST_PROTO_DEFINE_UNARY_OPERATOR(~, boost::proto::tag::complement, TRAIT, DOMAIN, 0) \ BOOST_PROTO_DEFINE_UNARY_OPERATOR(&, boost::proto::tag::address_of, TRAIT, DOMAIN, 0) \ BOOST_PROTO_DEFINE_UNARY_OPERATOR(!, boost::proto::tag::logical_not, TRAIT, DOMAIN, 0) \ BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, boost::proto::tag::pre_inc, TRAIT, DOMAIN, 0) \ BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, boost::proto::tag::pre_dec, TRAIT, DOMAIN, 0) \ BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, boost::proto::tag::post_inc, TRAIT, DOMAIN, 1) \ BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, boost::proto::tag::post_dec, TRAIT, DOMAIN, 1) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<, boost::proto::tag::shift_left, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>, boost::proto::tag::shift_right, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(*, boost::proto::tag::multiplies, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(/, boost::proto::tag::divides, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(%, boost::proto::tag::modulus, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(+, boost::proto::tag::plus, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(-, boost::proto::tag::minus, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<, boost::proto::tag::less, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>, boost::proto::tag::greater, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<=, boost::proto::tag::less_equal, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>=, boost::proto::tag::greater_equal, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(==, boost::proto::tag::equal_to, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(!=, boost::proto::tag::not_equal_to, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(||, boost::proto::tag::logical_or, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&&, boost::proto::tag::logical_and, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&, boost::proto::tag::bitwise_and, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(|, boost::proto::tag::bitwise_or, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(^, boost::proto::tag::bitwise_xor, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(BOOST_PP_COMMA(), boost::proto::tag::comma, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(->*, boost::proto::tag::mem_ptr, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<=, boost::proto::tag::shift_left_assign, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>=, boost::proto::tag::shift_right_assign, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(*=, boost::proto::tag::multiplies_assign, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(/=, boost::proto::tag::divides_assign, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(%=, boost::proto::tag::modulus_assign, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(+=, boost::proto::tag::plus_assign, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(-=, boost::proto::tag::minus_assign, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&=, boost::proto::tag::bitwise_and_assign, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(|=, boost::proto::tag::bitwise_or_assign, TRAIT, DOMAIN) \ BOOST_PROTO_DEFINE_BINARY_OPERATOR(^=, boost::proto::tag::bitwise_xor_assign, TRAIT, DOMAIN) \ /**/ // Extensions are a superset of Proto expressions template<typename T> struct is_extension : is_expr<T> {}; template<typename T> struct is_extension<T &> : is_expr<T> {}; #define BOOST_PROTO_APPLY_UNARY_(TRAIT, ARG) TRAIT<ARG> #define BOOST_PROTO_APPLY_BINARY_(TRAIT, LEFT, RIGHT) boost::mpl::or_<TRAIT<LEFT>, TRAIT<RIGHT> > namespace exprns_ { // This defines all of Proto's built-in free operator overloads BOOST_PROTO_DEFINE_OPERATORS(is_extension, deduce_domain) // if_else, for the non-overloadable ternary conditional operator ?: template<typename A0, typename A1, typename A2> BOOST_FORCEINLINE typename result_of::make_expr< tag::if_else_ , deduce_domain , A0 const & , A1 const & , A2 const & >::type const if_else(A0 const &a0, A1 const &a1, A2 const &a2) { return proto::detail::make_expr_< tag::if_else_ , deduce_domain , A0 const & , A1 const & , A2 const & >()(a0, a1, a2); } } using exprns_::if_else; #undef BOOST_PROTO_APPLY_UNARY_ #undef BOOST_PROTO_APPLY_BINARY_ // Redefine BOOST_PROTO_APPLY_UNARY_ and BOOST_PROTO_APPLY_BINARY_ so that end users // can use BOOST_PROTO_DEFINE_OPERATORS to define Proto operator overloads that work // with their own terminal types. #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES #define BOOST_PROTO_APPLY_UNARY_(TRAIT, ARG) \ boost::mpl::and_< \ TRAIT<ARG> \ , boost::mpl::not_<boost::proto::is_extension<ARG> > \ > \ /**/ #define BOOST_PROTO_APPLY_BINARY_(TRAIT, LEFT, RIGHT) \ boost::mpl::and_< \ boost::mpl::or_<TRAIT<LEFT>, TRAIT<RIGHT> > \ , boost::mpl::not_< \ boost::mpl::or_< \ boost::proto::is_extension<LEFT> \ , boost::proto::is_extension<RIGHT> \ > \ > \ > \ /**/ #else #define BOOST_PROTO_APPLY_UNARY_(TRAIT, ARG) \ boost::mpl::and_< \ TRAIT<BOOST_PROTO_UNCVREF(ARG) > \ , boost::mpl::not_<boost::proto::is_extension<ARG> > \ > \ /**/ #define BOOST_PROTO_APPLY_BINARY_(TRAIT, LEFT, RIGHT) \ boost::mpl::and_< \ boost::mpl::or_<TRAIT<BOOST_PROTO_UNCVREF(LEFT) >, TRAIT<BOOST_PROTO_UNCVREF(RIGHT) > > \ , boost::mpl::not_< \ boost::mpl::or_< \ boost::proto::is_extension<LEFT> \ , boost::proto::is_extension<RIGHT> \ > \ > \ > \ /**/ #endif }} #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[ ��P P context.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file context.hpp /// Includes all the context classes in the context/ sub-directory. // // Copyright 2008 Eric Niebler. 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_PROTO_CONTEXT_HPP_EAN_06_23_2007 #define BOOST_PROTO_CONTEXT_HPP_EAN_06_23_2007 #include <boost/proto/context/null.hpp> #include <boost/proto/context/default.hpp> #include <boost/proto/context/callable.hpp> #endif PK �J�[f��6V V detail/and_n.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/and_n.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/and_n.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file and_n.hpp /// Definitions of and_N, and_impl // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (2, BOOST_PP_MAX(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_MAX_LOGICAL_ARITY), <boost/proto/detail/and_n.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else // BOOST_PP_IS_ITERATING #define N BOOST_PP_ITERATION() // Assymetry here between the handling of and_N and or_N because // and_N is used by lambda_matches up to BOOST_PROTO_MAX_ARITY, // regardless of how low BOOST_PROTO_MAX_LOGICAL_ARITY is. template<bool B, BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), typename P)> struct BOOST_PP_CAT(and_, N) #if 2 == N : mpl::bool_<P0::value> {}; #else : BOOST_PP_CAT(and_, BOOST_PP_DEC(N))< P0::value BOOST_PP_COMMA_IF(BOOST_PP_SUB(N,2)) BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_DEC(N), P) > {}; #endif template<BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), typename P)> struct BOOST_PP_CAT(and_, N)<false, BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), P)> : mpl::false_ {}; #if N <= BOOST_PROTO_MAX_LOGICAL_ARITY template<BOOST_PP_ENUM_PARAMS(N, typename G), typename Expr, typename State, typename Data> struct _and_impl<proto::and_<BOOST_PP_ENUM_PARAMS(N, G)>, Expr, State, Data> : proto::transform_impl<Expr, State, Data> { #define M0(Z, N, DATA) \ typedef \ typename proto::when<proto::_, BOOST_PP_CAT(G, N)> \ ::template impl<Expr, State, Data> \ BOOST_PP_CAT(Gimpl, N); \ /**/ BOOST_PP_REPEAT(N, M0, ~) #undef M0 typedef typename BOOST_PP_CAT(Gimpl, BOOST_PP_DEC(N))::result_type result_type; result_type operator()( typename _and_impl::expr_param e , typename _and_impl::state_param s , typename _and_impl::data_param d ) const { // Fix: jfalcou - 12/29/2010 // Avoid the use of comma operator here so as not to find Proto's // by accident. // expands to G0()(e,s,d); G1()(e,s,d); ... G{N-1}()(e,s,d); #define M0(Z,N,DATA) BOOST_PP_CAT(Gimpl,N)()(e,s,d); BOOST_PP_REPEAT(BOOST_PP_DEC(N),M0,~) return BOOST_PP_CAT(Gimpl,BOOST_PP_DEC(N))()(e,s,d); #undef M0 } }; #endif #undef N #endif PK �J�[�V= = detail/make_expr_funop.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/make_expr_funop.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_expr_funop.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file make_expr_funop.hpp /// Contains definition of make_expr\<\>::operator() member functions. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/make_expr_funop.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else // BOOST_PP_IS_ITERATING #define N BOOST_PP_ITERATION() template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct result<This(BOOST_PP_ENUM_PARAMS(N, A))> { typedef typename result_of::make_expr< Tag , Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, A) >::type type; }; /// \overload /// template<BOOST_PP_ENUM_PARAMS(N, typename A)> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) >::type const operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, const A, &a)) const { return proto::detail::make_expr_< Tag , Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) >()(BOOST_PP_ENUM_PARAMS(N, a)); } #undef N #endif PK �J�[W�� � detail/vararg_matches_impl.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/vararg_matches_impl.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/vararg_matches_impl.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file vararg_matches_impl.hpp /// Specializations of the vararg_matches_impl template // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/vararg_matches_impl.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else // BOOST_PP_IS_ITERATING #define N BOOST_PP_ITERATION() template<typename Args, typename Back, long To> struct vararg_matches_impl<Args, Back, N, To> : and_2< matches_< typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_grammar , Back >::value , vararg_matches_impl<Args, Back, N + 1, To> > {}; template<typename Args, typename Back> struct vararg_matches_impl<Args, Back, N, N> : matches_< typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_grammar , Back > {}; #undef N #endif PK �J�[�)'� detail/class_member_traits.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/class_member_traits.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/class_member_traits.hpp") #endif /////////////////////////////////////////////////////////////////////////////// // class_member_traits.hpp // Contains specializations of the class_member_traits\<\> class template. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/class_member_traits.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else #define N BOOST_PP_ITERATION() template<typename T, typename U BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct class_member_traits<T (U::*)(BOOST_PP_ENUM_PARAMS(N, A))> { typedef U class_type; typedef T result_type; }; template<typename T, typename U BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct class_member_traits<T (U::*)(BOOST_PP_ENUM_PARAMS(N, A)) const> { typedef U class_type; typedef T result_type; }; #undef N #endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES PK �J�[2Ù�/= /= detail/preprocessed/and_n.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file and_n.hpp /// Definitions of and_N, and_impl // // Copyright 2008 Eric Niebler. 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) template<bool B, typename P0> struct and_2 : mpl::bool_<P0::value> {}; template<typename P0> struct and_2<false, P0> : mpl::false_ {}; template<typename G0 , typename G1, typename Expr, typename State, typename Data> struct _and_impl<proto::and_<G0 , G1>, Expr, State, Data> : proto::transform_impl<Expr, State, Data> { typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename Gimpl1::result_type result_type; result_type operator()( typename _and_impl::expr_param e , typename _and_impl::state_param s , typename _and_impl::data_param d ) const { Gimpl0()(e,s,d); return Gimpl1()(e,s,d); } }; template<bool B, typename P0 , typename P1> struct and_3 : and_2< P0::value , P1 > {}; template<typename P0 , typename P1> struct and_3<false, P0 , P1> : mpl::false_ {}; template<typename G0 , typename G1 , typename G2, typename Expr, typename State, typename Data> struct _and_impl<proto::and_<G0 , G1 , G2>, Expr, State, Data> : proto::transform_impl<Expr, State, Data> { typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename Gimpl2::result_type result_type; result_type operator()( typename _and_impl::expr_param e , typename _and_impl::state_param s , typename _and_impl::data_param d ) const { Gimpl0()(e,s,d); Gimpl1()(e,s,d); return Gimpl2()(e,s,d); } }; template<bool B, typename P0 , typename P1 , typename P2> struct and_4 : and_3< P0::value , P1 , P2 > {}; template<typename P0 , typename P1 , typename P2> struct and_4<false, P0 , P1 , P2> : mpl::false_ {}; template<typename G0 , typename G1 , typename G2 , typename G3, typename Expr, typename State, typename Data> struct _and_impl<proto::and_<G0 , G1 , G2 , G3>, Expr, State, Data> : proto::transform_impl<Expr, State, Data> { typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename Gimpl3::result_type result_type; result_type operator()( typename _and_impl::expr_param e , typename _and_impl::state_param s , typename _and_impl::data_param d ) const { Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); return Gimpl3()(e,s,d); } }; template<bool B, typename P0 , typename P1 , typename P2 , typename P3> struct and_5 : and_4< P0::value , P1 , P2 , P3 > {}; template<typename P0 , typename P1 , typename P2 , typename P3> struct and_5<false, P0 , P1 , P2 , P3> : mpl::false_ {}; template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4, typename Expr, typename State, typename Data> struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4>, Expr, State, Data> : proto::transform_impl<Expr, State, Data> { typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename Gimpl4::result_type result_type; result_type operator()( typename _and_impl::expr_param e , typename _and_impl::state_param s , typename _and_impl::data_param d ) const { Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); return Gimpl4()(e,s,d); } }; template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4> struct and_6 : and_5< P0::value , P1 , P2 , P3 , P4 > {}; template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4> struct and_6<false, P0 , P1 , P2 , P3 , P4> : mpl::false_ {}; template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5, typename Expr, typename State, typename Data> struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5>, Expr, State, Data> : proto::transform_impl<Expr, State, Data> { typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename Gimpl5::result_type result_type; result_type operator()( typename _and_impl::expr_param e , typename _and_impl::state_param s , typename _and_impl::data_param d ) const { Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); return Gimpl5()(e,s,d); } }; template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5> struct and_7 : and_6< P0::value , P1 , P2 , P3 , P4 , P5 > {}; template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5> struct and_7<false, P0 , P1 , P2 , P3 , P4 , P5> : mpl::false_ {}; template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6, typename Expr, typename State, typename Data> struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6>, Expr, State, Data> : proto::transform_impl<Expr, State, Data> { typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename Gimpl6::result_type result_type; result_type operator()( typename _and_impl::expr_param e , typename _and_impl::state_param s , typename _and_impl::data_param d ) const { Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); return Gimpl6()(e,s,d); } }; template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6> struct and_8 : and_7< P0::value , P1 , P2 , P3 , P4 , P5 , P6 > {}; template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6> struct and_8<false, P0 , P1 , P2 , P3 , P4 , P5 , P6> : mpl::false_ {}; template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7, typename Expr, typename State, typename Data> struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7>, Expr, State, Data> : proto::transform_impl<Expr, State, Data> { typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename Gimpl7::result_type result_type; result_type operator()( typename _and_impl::expr_param e , typename _and_impl::state_param s , typename _and_impl::data_param d ) const { Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); return Gimpl7()(e,s,d); } }; template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7> struct and_9 : and_8< P0::value , P1 , P2 , P3 , P4 , P5 , P6 , P7 > {}; template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7> struct and_9<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7> : mpl::false_ {}; template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8, typename Expr, typename State, typename Data> struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8>, Expr, State, Data> : proto::transform_impl<Expr, State, Data> { typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8; typedef typename Gimpl8::result_type result_type; result_type operator()( typename _and_impl::expr_param e , typename _and_impl::state_param s , typename _and_impl::data_param d ) const { Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d); return Gimpl8()(e,s,d); } }; template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8> struct and_10 : and_9< P0::value , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 > {}; template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8> struct and_10<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8> : mpl::false_ {}; template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9, typename Expr, typename State, typename Data> struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9>, Expr, State, Data> : proto::transform_impl<Expr, State, Data> { typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8; typedef typename proto::when<proto::_, G9> ::template impl<Expr, State, Data> Gimpl9; typedef typename Gimpl9::result_type result_type; result_type operator()( typename _and_impl::expr_param e , typename _and_impl::state_param s , typename _and_impl::data_param d ) const { Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d); Gimpl8()(e,s,d); return Gimpl9()(e,s,d); } }; PK �J�[IzG b# b# ' detail/preprocessed/make_expr_funop.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file make_expr_funop.hpp /// Contains definition of make_expr\<\>::operator() member functions. // // Copyright 2008 Eric Niebler. 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) template<typename This , typename A0 , typename A1> struct result<This(A0 , A1)> { typedef typename result_of::make_expr< Tag , Domain , A0 , A1 >::type type; }; template<typename A0 , typename A1> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const A0 , const A1 >::type const operator ()(const A0 &a0 , const A1 &a1) const { return proto::detail::make_expr_< Tag , Domain , const A0 , const A1 >()(a0 , a1); } template<typename This , typename A0 , typename A1 , typename A2> struct result<This(A0 , A1 , A2)> { typedef typename result_of::make_expr< Tag , Domain , A0 , A1 , A2 >::type type; }; template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const A0 , const A1 , const A2 >::type const operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2) const { return proto::detail::make_expr_< Tag , Domain , const A0 , const A1 , const A2 >()(a0 , a1 , a2); } template<typename This , typename A0 , typename A1 , typename A2 , typename A3> struct result<This(A0 , A1 , A2 , A3)> { typedef typename result_of::make_expr< Tag , Domain , A0 , A1 , A2 , A3 >::type type; }; template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const A0 , const A1 , const A2 , const A3 >::type const operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3) const { return proto::detail::make_expr_< Tag , Domain , const A0 , const A1 , const A2 , const A3 >()(a0 , a1 , a2 , a3); } template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct result<This(A0 , A1 , A2 , A3 , A4)> { typedef typename result_of::make_expr< Tag , Domain , A0 , A1 , A2 , A3 , A4 >::type type; }; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type const operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4) const { return proto::detail::make_expr_< Tag , Domain , const A0 , const A1 , const A2 , const A3 , const A4 >()(a0 , a1 , a2 , a3 , a4); } template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct result<This(A0 , A1 , A2 , A3 , A4 , A5)> { typedef typename result_of::make_expr< Tag , Domain , A0 , A1 , A2 , A3 , A4 , A5 >::type type; }; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type const operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5) const { return proto::detail::make_expr_< Tag , Domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >()(a0 , a1 , a2 , a3 , a4 , a5); } template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6)> { typedef typename result_of::make_expr< Tag , Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 >::type type; }; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type const operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6) const { return proto::detail::make_expr_< Tag , Domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >()(a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> { typedef typename result_of::make_expr< Tag , Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 >::type type; }; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type const operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7) const { return proto::detail::make_expr_< Tag , Domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> { typedef typename result_of::make_expr< Tag , Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >::type type; }; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type const operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8) const { return proto::detail::make_expr_< Tag , Domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> { typedef typename result_of::make_expr< Tag , Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >::type type; }; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9 >::type const operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8 , const A9 &a9) const { return proto::detail::make_expr_< Tag , Domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9 >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); } PK �J�[�0=L� � + detail/preprocessed/vararg_matches_impl.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file vararg_matches_impl.hpp /// Specializations of the vararg_matches_impl template // // Copyright 2008 Eric Niebler. 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) template<typename Args, typename Back, long To> struct vararg_matches_impl<Args, Back, 2, To> : and_2< matches_< typename detail::expr_traits<typename Args::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child1>::value_type::proto_grammar , Back >::value , vararg_matches_impl<Args, Back, 2 + 1, To> > {}; template<typename Args, typename Back> struct vararg_matches_impl<Args, Back, 2, 2> : matches_< typename detail::expr_traits<typename Args::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child1>::value_type::proto_grammar , Back > {}; template<typename Args, typename Back, long To> struct vararg_matches_impl<Args, Back, 3, To> : and_2< matches_< typename detail::expr_traits<typename Args::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child2>::value_type::proto_grammar , Back >::value , vararg_matches_impl<Args, Back, 3 + 1, To> > {}; template<typename Args, typename Back> struct vararg_matches_impl<Args, Back, 3, 3> : matches_< typename detail::expr_traits<typename Args::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child2>::value_type::proto_grammar , Back > {}; template<typename Args, typename Back, long To> struct vararg_matches_impl<Args, Back, 4, To> : and_2< matches_< typename detail::expr_traits<typename Args::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child3>::value_type::proto_grammar , Back >::value , vararg_matches_impl<Args, Back, 4 + 1, To> > {}; template<typename Args, typename Back> struct vararg_matches_impl<Args, Back, 4, 4> : matches_< typename detail::expr_traits<typename Args::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child3>::value_type::proto_grammar , Back > {}; template<typename Args, typename Back, long To> struct vararg_matches_impl<Args, Back, 5, To> : and_2< matches_< typename detail::expr_traits<typename Args::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child4>::value_type::proto_grammar , Back >::value , vararg_matches_impl<Args, Back, 5 + 1, To> > {}; template<typename Args, typename Back> struct vararg_matches_impl<Args, Back, 5, 5> : matches_< typename detail::expr_traits<typename Args::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child4>::value_type::proto_grammar , Back > {}; template<typename Args, typename Back, long To> struct vararg_matches_impl<Args, Back, 6, To> : and_2< matches_< typename detail::expr_traits<typename Args::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child5>::value_type::proto_grammar , Back >::value , vararg_matches_impl<Args, Back, 6 + 1, To> > {}; template<typename Args, typename Back> struct vararg_matches_impl<Args, Back, 6, 6> : matches_< typename detail::expr_traits<typename Args::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child5>::value_type::proto_grammar , Back > {}; template<typename Args, typename Back, long To> struct vararg_matches_impl<Args, Back, 7, To> : and_2< matches_< typename detail::expr_traits<typename Args::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child6>::value_type::proto_grammar , Back >::value , vararg_matches_impl<Args, Back, 7 + 1, To> > {}; template<typename Args, typename Back> struct vararg_matches_impl<Args, Back, 7, 7> : matches_< typename detail::expr_traits<typename Args::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child6>::value_type::proto_grammar , Back > {}; template<typename Args, typename Back, long To> struct vararg_matches_impl<Args, Back, 8, To> : and_2< matches_< typename detail::expr_traits<typename Args::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child7>::value_type::proto_grammar , Back >::value , vararg_matches_impl<Args, Back, 8 + 1, To> > {}; template<typename Args, typename Back> struct vararg_matches_impl<Args, Back, 8, 8> : matches_< typename detail::expr_traits<typename Args::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child7>::value_type::proto_grammar , Back > {}; template<typename Args, typename Back, long To> struct vararg_matches_impl<Args, Back, 9, To> : and_2< matches_< typename detail::expr_traits<typename Args::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child8>::value_type::proto_grammar , Back >::value , vararg_matches_impl<Args, Back, 9 + 1, To> > {}; template<typename Args, typename Back> struct vararg_matches_impl<Args, Back, 9, 9> : matches_< typename detail::expr_traits<typename Args::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child8>::value_type::proto_grammar , Back > {}; template<typename Args, typename Back, long To> struct vararg_matches_impl<Args, Back, 10, To> : and_2< matches_< typename detail::expr_traits<typename Args::child9>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child9>::value_type::proto_grammar , Back >::value , vararg_matches_impl<Args, Back, 10 + 1, To> > {}; template<typename Args, typename Back> struct vararg_matches_impl<Args, Back, 10, 10> : matches_< typename detail::expr_traits<typename Args::child9>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args::child9>::value_type::proto_grammar , Back > {}; PK �J�[dj�� � + detail/preprocessed/class_member_traits.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// // class_member_traits.hpp // Contains specializations of the class_member_traits\<\> class template. // // Copyright 2008 Eric Niebler. 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) template<typename T, typename U > struct class_member_traits<T (U::*)()> { typedef U class_type; typedef T result_type; }; template<typename T, typename U > struct class_member_traits<T (U::*)() const> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0> struct class_member_traits<T (U::*)(A0)> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0> struct class_member_traits<T (U::*)(A0) const> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1> struct class_member_traits<T (U::*)(A0 , A1)> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1> struct class_member_traits<T (U::*)(A0 , A1) const> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2> struct class_member_traits<T (U::*)(A0 , A1 , A2)> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2> struct class_member_traits<T (U::*)(A0 , A1 , A2) const> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3> struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3)> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3> struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3) const> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4)> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4) const> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5)> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5) const> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6)> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6) const> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) const> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) const> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> { typedef U class_type; typedef T result_type; }; template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) const> { typedef U class_type; typedef T result_type; }; PK �J�[sv��Q Q detail/preprocessed/or_n.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file or_n.hpp /// Definitions of or_N // // Copyright 2008 Eric Niebler. 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) template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1> struct or_2 : mpl::bool_<matches_<Expr, BasicExpr, typename G1::proto_grammar>::value> { typedef G1 which; }; template<typename Expr, typename BasicExpr , typename G0 , typename G1> struct or_2<true, Expr, BasicExpr, G0 , G1> : mpl::true_ { typedef G0 which; }; template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2> struct or_3 : or_2< matches_<Expr, BasicExpr, typename G1::proto_grammar>::value , Expr, BasicExpr, G1 , G2 > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2> struct or_3<true, Expr, BasicExpr, G0 , G1 , G2> : mpl::true_ { typedef G0 which; }; template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3> struct or_4 : or_3< matches_<Expr, BasicExpr, typename G1::proto_grammar>::value , Expr, BasicExpr, G1 , G2 , G3 > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3> struct or_4<true, Expr, BasicExpr, G0 , G1 , G2 , G3> : mpl::true_ { typedef G0 which; }; template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4> struct or_5 : or_4< matches_<Expr, BasicExpr, typename G1::proto_grammar>::value , Expr, BasicExpr, G1 , G2 , G3 , G4 > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4> struct or_5<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4> : mpl::true_ { typedef G0 which; }; template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5> struct or_6 : or_5< matches_<Expr, BasicExpr, typename G1::proto_grammar>::value , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5> struct or_6<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5> : mpl::true_ { typedef G0 which; }; template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6> struct or_7 : or_6< matches_<Expr, BasicExpr, typename G1::proto_grammar>::value , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6> struct or_7<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6> : mpl::true_ { typedef G0 which; }; template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7> struct or_8 : or_7< matches_<Expr, BasicExpr, typename G1::proto_grammar>::value , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7 > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7> struct or_8<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7> : mpl::true_ { typedef G0 which; }; template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8> struct or_9 : or_8< matches_<Expr, BasicExpr, typename G1::proto_grammar>::value , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8> struct or_9<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8> : mpl::true_ { typedef G0 which; }; template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9> struct or_10 : or_9< matches_<Expr, BasicExpr, typename G1::proto_grammar>::value , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9 > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9> struct or_10<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> : mpl::true_ { typedef G0 which; }; PK �J�[0l�RQW QW " detail/preprocessed/basic_expr.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file basic_expr.hpp /// Contains definition of basic_expr\<\> class template. // // Copyright 2008 Eric Niebler. 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) template<typename Tag, typename Arg0> struct basic_expr<Tag, term<Arg0>, 0> { typedef Tag proto_tag; static const long proto_arity_c = 0; typedef mpl::long_<0 > proto_arity; typedef basic_expr proto_base_expr; typedef term<Arg0> proto_args; typedef basic_expr proto_grammar; typedef basic_default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef basic_expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE basic_expr const &proto_base() const { return *this; } BOOST_FORCEINLINE basic_expr &proto_base() { return *this; } template<typename A0> BOOST_FORCEINLINE static basic_expr const make(A0 &a0) { return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0)); } template<typename A0> BOOST_FORCEINLINE static basic_expr const make(A0 const &a0) { return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0)); } typedef detail::not_a_valid_type address_of_hack_type_; }; template<typename Tag , typename Arg0> struct basic_expr<Tag, list1<Arg0>, 1 > { typedef Tag proto_tag; static const long proto_arity_c = 1; typedef mpl::long_<1 > proto_arity; typedef basic_expr proto_base_expr; typedef list1<Arg0> proto_args; typedef basic_expr proto_grammar; typedef basic_default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef basic_expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE basic_expr const &proto_base() const { return *this; } BOOST_FORCEINLINE basic_expr &proto_base() { return *this; } template<typename A0> BOOST_FORCEINLINE static basic_expr const make(A0 const &a0) { basic_expr that = {a0}; return that; } typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_; BOOST_FORCEINLINE operator address_of_hack_type_() const { return boost::addressof(this->child0); } }; template<typename Tag , typename Arg0 , typename Arg1> struct basic_expr<Tag, list2<Arg0 , Arg1>, 2 > { typedef Tag proto_tag; static const long proto_arity_c = 2; typedef mpl::long_<2 > proto_arity; typedef basic_expr proto_base_expr; typedef list2<Arg0 , Arg1> proto_args; typedef basic_expr proto_grammar; typedef basic_default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef basic_expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE basic_expr const &proto_base() const { return *this; } BOOST_FORCEINLINE basic_expr &proto_base() { return *this; } template<typename A0 , typename A1> BOOST_FORCEINLINE static basic_expr const make(A0 const &a0 , A1 const &a1) { basic_expr that = {a0 , a1}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2> struct basic_expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3 > { typedef Tag proto_tag; static const long proto_arity_c = 3; typedef mpl::long_<3 > proto_arity; typedef basic_expr proto_base_expr; typedef list3<Arg0 , Arg1 , Arg2> proto_args; typedef basic_expr proto_grammar; typedef basic_default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef basic_expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE basic_expr const &proto_base() const { return *this; } BOOST_FORCEINLINE basic_expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2) { basic_expr that = {a0 , a1 , a2}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3> struct basic_expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4 > { typedef Tag proto_tag; static const long proto_arity_c = 4; typedef mpl::long_<4 > proto_arity; typedef basic_expr proto_base_expr; typedef list4<Arg0 , Arg1 , Arg2 , Arg3> proto_args; typedef basic_expr proto_grammar; typedef basic_default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef basic_expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE basic_expr const &proto_base() const { return *this; } BOOST_FORCEINLINE basic_expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) { basic_expr that = {a0 , a1 , a2 , a3}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4> struct basic_expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5 > { typedef Tag proto_tag; static const long proto_arity_c = 5; typedef mpl::long_<5 > proto_arity; typedef basic_expr proto_base_expr; typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> proto_args; typedef basic_expr proto_grammar; typedef basic_default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef basic_expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE basic_expr const &proto_base() const { return *this; } BOOST_FORCEINLINE basic_expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) { basic_expr that = {a0 , a1 , a2 , a3 , a4}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5> struct basic_expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 > { typedef Tag proto_tag; static const long proto_arity_c = 6; typedef mpl::long_<6 > proto_arity; typedef basic_expr proto_base_expr; typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args; typedef basic_expr proto_grammar; typedef basic_default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef basic_expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE basic_expr const &proto_base() const { return *this; } BOOST_FORCEINLINE basic_expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) { basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6> struct basic_expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 > { typedef Tag proto_tag; static const long proto_arity_c = 7; typedef mpl::long_<7 > proto_arity; typedef basic_expr proto_base_expr; typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args; typedef basic_expr proto_grammar; typedef basic_default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef basic_expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE basic_expr const &proto_base() const { return *this; } BOOST_FORCEINLINE basic_expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) { basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7> struct basic_expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 > { typedef Tag proto_tag; static const long proto_arity_c = 8; typedef mpl::long_<8 > proto_arity; typedef basic_expr proto_base_expr; typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args; typedef basic_expr proto_grammar; typedef basic_default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef basic_expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE basic_expr const &proto_base() const { return *this; } BOOST_FORCEINLINE basic_expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) { basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8> struct basic_expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 > { typedef Tag proto_tag; static const long proto_arity_c = 9; typedef mpl::long_<9 > proto_arity; typedef basic_expr proto_base_expr; typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args; typedef basic_expr proto_grammar; typedef basic_default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef basic_expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef void proto_child9; BOOST_FORCEINLINE basic_expr const &proto_base() const { return *this; } BOOST_FORCEINLINE basic_expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) { basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9> struct basic_expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 > { typedef Tag proto_tag; static const long proto_arity_c = 10; typedef mpl::long_<10 > proto_arity; typedef basic_expr proto_base_expr; typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args; typedef basic_expr proto_grammar; typedef basic_default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef basic_expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9; BOOST_FORCEINLINE basic_expr const &proto_base() const { return *this; } BOOST_FORCEINLINE basic_expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> BOOST_FORCEINLINE static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) { basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; }; PK �J�[�O�h h + detail/preprocessed/extends_funop_const.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file extends_funop_const.hpp /// Definitions for extends\<\>::operator() // // Copyright 2008 Eric Niebler. 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) template<typename Sig> struct result { typedef typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop< Sig , proto_derived_expr , proto_domain >::type ) >::type const type; }; BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr const , proto_domain >::type ) >::type const operator ()() const { typedef boost::proto::result_of::funop0< proto_derived_expr const , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) ) ); } template<typename A0> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) const { typedef boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 ) ); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) const { typedef boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 ) ); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { typedef boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { typedef boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { typedef boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { typedef boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { typedef boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { typedef boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { typedef boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); } PK �J�[���6 �6 + detail/preprocessed/poly_function_funop.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// // poly_function_funop.hpp // Contains overloads of poly_function\<\>::operator() // // Copyright 2008 Eric Niebler. 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) template<typename This , typename A0> struct result<This(A0)> : Derived::template impl< typename normalize_arg<A0 >::type > { typedef typename result::result_type type; }; template<typename A0> typename result< Derived const( A0 const & ) >::type operator ()(A0 const &a0) const { result< Derived const( A0 const & ) > impl; return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0)); } template<typename This , typename A0 , typename A1> struct result<This(A0 , A1)> : Derived::template impl< typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type > { typedef typename result::result_type type; }; template<typename A0 , typename A1> typename result< Derived const( A0 const & , A1 const & ) >::type operator ()(A0 const &a0 , A1 const &a1) const { result< Derived const( A0 const & , A1 const & ) > impl; return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1)); } template<typename This , typename A0 , typename A1 , typename A2> struct result<This(A0 , A1 , A2)> : Derived::template impl< typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type > { typedef typename result::result_type type; }; template<typename A0 , typename A1 , typename A2> typename result< Derived const( A0 const & , A1 const & , A2 const & ) >::type operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { result< Derived const( A0 const & , A1 const & , A2 const & ) > impl; return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2)); } template<typename This , typename A0 , typename A1 , typename A2 , typename A3> struct result<This(A0 , A1 , A2 , A3)> : Derived::template impl< typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type > { typedef typename result::result_type type; }; template<typename A0 , typename A1 , typename A2 , typename A3> typename result< Derived const( A0 const & , A1 const & , A2 const & , A3 const & ) >::type operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { result< Derived const( A0 const & , A1 const & , A2 const & , A3 const & ) > impl; return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3)); } template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct result<This(A0 , A1 , A2 , A3 , A4)> : Derived::template impl< typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type > { typedef typename result::result_type type; }; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> typename result< Derived const( A0 const & , A1 const & , A2 const & , A3 const & , A4 const & ) >::type operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { result< Derived const( A0 const & , A1 const & , A2 const & , A3 const & , A4 const & ) > impl; return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4)); } template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct result<This(A0 , A1 , A2 , A3 , A4 , A5)> : Derived::template impl< typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type > { typedef typename result::result_type type; }; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> typename result< Derived const( A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & ) >::type operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { result< Derived const( A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & ) > impl; return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5)); } template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : Derived::template impl< typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type > { typedef typename result::result_type type; }; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> typename result< Derived const( A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & ) >::type operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { result< Derived const( A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & ) > impl; return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6)); } template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : Derived::template impl< typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type > { typedef typename result::result_type type; }; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> typename result< Derived const( A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & ) >::type operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { result< Derived const( A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & ) > impl; return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7)); } template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : Derived::template impl< typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type , typename normalize_arg<A8 >::type > { typedef typename result::result_type type; }; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> typename result< Derived const( A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const & ) >::type operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { result< Derived const( A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const & ) > impl; return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7) , static_cast<typename normalize_arg<A8 const &> ::reference>(a8)); } template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : Derived::template impl< typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type , typename normalize_arg<A8 >::type , typename normalize_arg<A9 >::type > { typedef typename result::result_type type; }; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> typename result< Derived const( A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const & , A9 const & ) >::type operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) const { result< Derived const( A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const & , A9 const & ) > impl; return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7) , static_cast<typename normalize_arg<A8 const &> ::reference>(a8) , static_cast<typename normalize_arg<A9 const &> ::reference>(a9)); } PK �J�[���{ { - detail/preprocessed/template_arity_helper.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// // template_arity_helper.hpp // Overloads of template_arity_helper, used by the template_arity\<\> class template // // Copyright 2008 Eric Niebler. 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) template< template<typename P0> class F , typename T0 > sized_type<2>::type template_arity_helper(F<T0> **, mpl::int_<1> *); template< template<typename P0 , typename P1> class F , typename T0 , typename T1 > sized_type<3>::type template_arity_helper(F<T0 , T1> **, mpl::int_<2> *); template< template<typename P0 , typename P1 , typename P2> class F , typename T0 , typename T1 , typename T2 > sized_type<4>::type template_arity_helper(F<T0 , T1 , T2> **, mpl::int_<3> *); template< template<typename P0 , typename P1 , typename P2 , typename P3> class F , typename T0 , typename T1 , typename T2 , typename T3 > sized_type<5>::type template_arity_helper(F<T0 , T1 , T2 , T3> **, mpl::int_<4> *); template< template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4> class F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 > sized_type<6>::type template_arity_helper(F<T0 , T1 , T2 , T3 , T4> **, mpl::int_<5> *); template< template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5> class F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > sized_type<7>::type template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5> **, mpl::int_<6> *); template< template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6> class F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > sized_type<8>::type template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6> **, mpl::int_<7> *); template< template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7> class F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 > sized_type<9>::type template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> **, mpl::int_<8> *); template< template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8> class F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 > sized_type<10>::type template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> **, mpl::int_<9> *); template< template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8 , typename P9> class F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 > sized_type<11>::type template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> **, mpl::int_<10> *); PK �J�[��6l l detail/preprocessed/args.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file args.hpp /// Contains definition of \c term\<\>, \c list1\<\>, \c list2\<\>, ... /// class templates. // // Copyright 2008 Eric Niebler. 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) template< typename Arg0 > struct term { static const long arity = 0; typedef Arg0 child0; typedef mpl::void_ child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; typedef Arg0 back_; }; template< typename Arg0 > struct list1 { static const long arity = 1; typedef Arg0 child0; typedef mpl::void_ child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; typedef Arg0 back_; }; template< typename Arg0 , typename Arg1 > struct list2 { static const long arity = 2; typedef Arg0 child0; typedef Arg1 child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; typedef Arg1 back_; }; template< typename Arg0 , typename Arg1 , typename Arg2 > struct list3 { static const long arity = 3; typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; typedef Arg2 back_; }; template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 > struct list4 { static const long arity = 4; typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; typedef Arg3 back_; }; template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 > struct list5 { static const long arity = 5; typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; typedef Arg4 back_; }; template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 > struct list6 { static const long arity = 6; typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; typedef Arg5 back_; }; template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 > struct list7 { static const long arity = 7; typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; typedef Arg6 back_; }; template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 > struct list8 { static const long arity = 8; typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7; typedef mpl::void_ child8; typedef mpl::void_ child9; typedef Arg7 back_; }; template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 > struct list9 { static const long arity = 9; typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7; typedef Arg8 child8; typedef mpl::void_ child9; typedef Arg8 back_; }; template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 > struct list10 { static const long arity = 10; typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7; typedef Arg8 child8; typedef Arg9 child9; typedef Arg9 back_; }; PK �J�[9Ɯ�� � $ detail/preprocessed/memfun_funop.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// // memfun_funop.hpp // Contains overloads of memfun::operator(). // // Copyright 2008 Eric Niebler. 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) template<typename A0> BOOST_FORCEINLINE result_type operator()(A0 const &a0) const { BOOST_PROTO_USE_GET_POINTER(); return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0); } template<typename A0 , typename A1> BOOST_FORCEINLINE result_type operator()(A0 const &a0 , A1 const &a1) const { BOOST_PROTO_USE_GET_POINTER(); return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { BOOST_PROTO_USE_GET_POINTER(); return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { BOOST_PROTO_USE_GET_POINTER(); return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { BOOST_PROTO_USE_GET_POINTER(); return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { BOOST_PROTO_USE_GET_POINTER(); return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { BOOST_PROTO_USE_GET_POINTER(); return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { BOOST_PROTO_USE_GET_POINTER(); return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { BOOST_PROTO_USE_GET_POINTER(); return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> BOOST_FORCEINLINE result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) const { BOOST_PROTO_USE_GET_POINTER(); return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); } PK �J�[��: �: detail/preprocessed/funop.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// // funop.hpp // Contains definition of funop[n]\<\> class template. // // Copyright 2008 Eric Niebler. 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) template<typename Expr, typename Domain > struct funop0 { typedef typename proto::base_expr< Domain , tag::function , list1< Expr & > >::type type; BOOST_FORCEINLINE static type const call( Expr &e ) { type that = { e }; return that; } }; template<typename Expr , typename This, typename Domain> struct funop<Expr(), This, Domain> : funop0< typename detail::same_cv<Expr, This>::type , Domain > {}; template<typename Expr, typename Domain , typename A0> struct funop1 { typedef typename proto::base_expr< Domain , tag::function , list2< Expr & , typename proto::result_of::as_child<A0, Domain>::type > >::type type; BOOST_FORCEINLINE static type const call( Expr &e , A0 &a0 ) { type that = { e , proto::as_child<Domain>(a0) }; return that; } }; template<typename Expr , typename A0, typename This, typename Domain> struct funop<Expr(A0), This, Domain> : funop1< typename detail::same_cv<Expr, This>::type , Domain , typename remove_reference<A0 >::type > {}; template<typename Expr, typename Domain , typename A0 , typename A1> struct funop2 { typedef typename proto::base_expr< Domain , tag::function , list3< Expr & , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type > >::type type; BOOST_FORCEINLINE static type const call( Expr &e , A0 &a0 , A1 &a1 ) { type that = { e , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) }; return that; } }; template<typename Expr , typename A0 , typename A1, typename This, typename Domain> struct funop<Expr(A0 , A1), This, Domain> : funop2< typename detail::same_cv<Expr, This>::type , Domain , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type > {}; template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2> struct funop3 { typedef typename proto::base_expr< Domain , tag::function , list4< Expr & , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type > >::type type; BOOST_FORCEINLINE static type const call( Expr &e , A0 &a0 , A1 &a1 , A2 &a2 ) { type that = { e , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) }; return that; } }; template<typename Expr , typename A0 , typename A1 , typename A2, typename This, typename Domain> struct funop<Expr(A0 , A1 , A2), This, Domain> : funop3< typename detail::same_cv<Expr, This>::type , Domain , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type > {}; template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3> struct funop4 { typedef typename proto::base_expr< Domain , tag::function , list5< Expr & , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type > >::type type; BOOST_FORCEINLINE static type const call( Expr &e , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 ) { type that = { e , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) }; return that; } }; template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3, typename This, typename Domain> struct funop<Expr(A0 , A1 , A2 , A3), This, Domain> : funop4< typename detail::same_cv<Expr, This>::type , Domain , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type > {}; template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct funop5 { typedef typename proto::base_expr< Domain , tag::function , list6< Expr & , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type > >::type type; BOOST_FORCEINLINE static type const call( Expr &e , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 ) { type that = { e , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) }; return that; } }; template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4, typename This, typename Domain> struct funop<Expr(A0 , A1 , A2 , A3 , A4), This, Domain> : funop5< typename detail::same_cv<Expr, This>::type , Domain , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type > {}; template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct funop6 { typedef typename proto::base_expr< Domain , tag::function , list7< Expr & , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type > >::type type; BOOST_FORCEINLINE static type const call( Expr &e , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 ) { type that = { e , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) }; return that; } }; template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5, typename This, typename Domain> struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5), This, Domain> : funop6< typename detail::same_cv<Expr, This>::type , Domain , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type > {}; template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct funop7 { typedef typename proto::base_expr< Domain , tag::function , list8< Expr & , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type > >::type type; BOOST_FORCEINLINE static type const call( Expr &e , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 ) { type that = { e , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) }; return that; } }; template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6, typename This, typename Domain> struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6), This, Domain> : funop7< typename detail::same_cv<Expr, This>::type , Domain , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type > {}; template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct funop8 { typedef typename proto::base_expr< Domain , tag::function , list9< Expr & , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type , typename proto::result_of::as_child<A7, Domain>::type > >::type type; BOOST_FORCEINLINE static type const call( Expr &e , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 ) { type that = { e , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) , proto::as_child<Domain>(a7) }; return that; } }; template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7, typename This, typename Domain> struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), This, Domain> : funop8< typename detail::same_cv<Expr, This>::type , Domain , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type > {}; template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct funop9 { typedef typename proto::base_expr< Domain , tag::function , list10< Expr & , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type , typename proto::result_of::as_child<A7, Domain>::type , typename proto::result_of::as_child<A8, Domain>::type > >::type type; BOOST_FORCEINLINE static type const call( Expr &e , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 ) { type that = { e , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) , proto::as_child<Domain>(a7) , proto::as_child<Domain>(a8) }; return that; } }; template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8, typename This, typename Domain> struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), This, Domain> : funop9< typename detail::same_cv<Expr, This>::type , Domain , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type , typename remove_reference<A8 >::type > {}; PK �J�[�o�Ұ Ұ $ detail/preprocessed/unpack_expr_.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file make_expr_.hpp /// Contains definition of make_expr_\<\> class template. // // Copyright 2008 Eric Niebler. 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) template<typename Tag, typename Domain, typename Sequence, std::size_t Size> struct unpack_expr_ {}; template<typename Domain, typename Sequence> struct unpack_expr_<tag::terminal, Domain, Sequence, 1u> { typedef typename add_const< typename fusion::result_of::value_of< typename fusion::result_of::begin<Sequence>::type >::type >::type terminal_type; typedef typename proto::detail::protoify< terminal_type , Domain >::result_type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { return proto::detail::protoify<terminal_type, Domain>()(fusion::at_c<0>(sequence)); } }; template<typename Sequence> struct unpack_expr_<tag::terminal, deduce_domain, Sequence, 1u> : unpack_expr_<tag::terminal, default_domain, Sequence, 1u> {}; template<typename Tag, typename Domain, typename Sequence> struct unpack_expr_<Tag, Domain, Sequence, 1> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef list1< typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { fusion_iterator0 it0 = fusion::begin(sequence); expr_type const that = { detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) }; return proto_generator()(that); } }; template<typename Tag, typename Sequence> struct unpack_expr_<Tag, deduce_domain, Sequence, 1> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef unpack_expr_< Tag , typename deduce_domain1< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type >::type , Sequence , 1 > other; typedef typename other::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { return other::call(sequence); } }; template<typename Tag, typename Domain, typename Sequence> struct unpack_expr_<Tag, Domain, Sequence, 2> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef list2< typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); expr_type const that = { detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) }; return proto_generator()(that); } }; template<typename Tag, typename Sequence> struct unpack_expr_<Tag, deduce_domain, Sequence, 2> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef unpack_expr_< Tag , typename deduce_domain2< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type >::type , Sequence , 2 > other; typedef typename other::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { return other::call(sequence); } }; template<typename Tag, typename Domain, typename Sequence> struct unpack_expr_<Tag, Domain, Sequence, 3> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef list3< typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); expr_type const that = { detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) }; return proto_generator()(that); } }; template<typename Tag, typename Sequence> struct unpack_expr_<Tag, deduce_domain, Sequence, 3> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef unpack_expr_< Tag , typename deduce_domain3< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type >::type , Sequence , 3 > other; typedef typename other::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { return other::call(sequence); } }; template<typename Tag, typename Domain, typename Sequence> struct unpack_expr_<Tag, Domain, Sequence, 4> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef list4< typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); expr_type const that = { detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) }; return proto_generator()(that); } }; template<typename Tag, typename Sequence> struct unpack_expr_<Tag, deduce_domain, Sequence, 4> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef unpack_expr_< Tag , typename deduce_domain4< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type >::type , Sequence , 4 > other; typedef typename other::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { return other::call(sequence); } }; template<typename Tag, typename Domain, typename Sequence> struct unpack_expr_<Tag, Domain, Sequence, 5> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef list5< typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); expr_type const that = { detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) }; return proto_generator()(that); } }; template<typename Tag, typename Sequence> struct unpack_expr_<Tag, deduce_domain, Sequence, 5> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef unpack_expr_< Tag , typename deduce_domain5< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type >::type , Sequence , 5 > other; typedef typename other::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { return other::call(sequence); } }; template<typename Tag, typename Domain, typename Sequence> struct unpack_expr_<Tag, Domain, Sequence, 6> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef list6< typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); expr_type const that = { detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) }; return proto_generator()(that); } }; template<typename Tag, typename Sequence> struct unpack_expr_<Tag, deduce_domain, Sequence, 6> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef unpack_expr_< Tag , typename deduce_domain6< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type >::type , Sequence , 6 > other; typedef typename other::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { return other::call(sequence); } }; template<typename Tag, typename Domain, typename Sequence> struct unpack_expr_<Tag, Domain, Sequence, 7> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef list7< typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); expr_type const that = { detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) }; return proto_generator()(that); } }; template<typename Tag, typename Sequence> struct unpack_expr_<Tag, deduce_domain, Sequence, 7> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef unpack_expr_< Tag , typename deduce_domain7< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type >::type , Sequence , 7 > other; typedef typename other::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { return other::call(sequence); } }; template<typename Tag, typename Domain, typename Sequence> struct unpack_expr_<Tag, Domain, Sequence, 8> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef list8< typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6); expr_type const that = { detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7) }; return proto_generator()(that); } }; template<typename Tag, typename Sequence> struct unpack_expr_<Tag, deduce_domain, Sequence, 8> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef unpack_expr_< Tag , typename deduce_domain8< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type >::type , Sequence , 8 > other; typedef typename other::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { return other::call(sequence); } }; template<typename Tag, typename Domain, typename Sequence> struct unpack_expr_<Tag, Domain, Sequence, 9> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; typedef list9< typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6); fusion_iterator8 it8 = fusion::next(it7); expr_type const that = { detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >()(*it8) }; return proto_generator()(that); } }; template<typename Tag, typename Sequence> struct unpack_expr_<Tag, deduce_domain, Sequence, 9> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; typedef unpack_expr_< Tag , typename deduce_domain9< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type >::type , Sequence , 9 > other; typedef typename other::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { return other::call(sequence); } }; template<typename Tag, typename Domain, typename Sequence> struct unpack_expr_<Tag, Domain, Sequence, 10> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; typedef typename fusion::result_of::next< fusion_iterator8>::type fusion_iterator9; typedef list10< typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6); fusion_iterator8 it8 = fusion::next(it7); fusion_iterator9 it9 = fusion::next(it8); expr_type const that = { detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >()(*it8) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type , Domain >()(*it9) }; return proto_generator()(that); } }; template<typename Tag, typename Sequence> struct unpack_expr_<Tag, deduce_domain, Sequence, 10> { typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; typedef typename fusion::result_of::next< fusion_iterator8>::type fusion_iterator9; typedef unpack_expr_< Tag , typename deduce_domain10< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type >::type , Sequence , 10 > other; typedef typename other::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { return other::call(sequence); } }; PK �J�[� ��>B >B ! detail/preprocessed/deep_copy.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file deep_copy.hpp /// Replace all nodes stored by reference by nodes stored by value. // // Copyright 2008 Eric Niebler. 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) template<typename Expr> struct deep_copy_impl<Expr, 1> { typedef typename base_expr< typename Expr::proto_domain , typename Expr::proto_tag , list1< typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type > >::type expr_type; typedef typename Expr::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; template<typename Expr2, typename S, typename D> result_type operator()(Expr2 const &e, S const &, D const &) const { expr_type const that = { proto::deep_copy(e.proto_base().child0) }; return proto_generator()(that); } }; template<typename Expr> struct deep_copy_impl<Expr, 2> { typedef typename base_expr< typename Expr::proto_domain , typename Expr::proto_tag , list2< typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type > >::type expr_type; typedef typename Expr::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; template<typename Expr2, typename S, typename D> result_type operator()(Expr2 const &e, S const &, D const &) const { expr_type const that = { proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) }; return proto_generator()(that); } }; template<typename Expr> struct deep_copy_impl<Expr, 3> { typedef typename base_expr< typename Expr::proto_domain , typename Expr::proto_tag , list3< typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type > >::type expr_type; typedef typename Expr::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; template<typename Expr2, typename S, typename D> result_type operator()(Expr2 const &e, S const &, D const &) const { expr_type const that = { proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) }; return proto_generator()(that); } }; template<typename Expr> struct deep_copy_impl<Expr, 4> { typedef typename base_expr< typename Expr::proto_domain , typename Expr::proto_tag , list4< typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type > >::type expr_type; typedef typename Expr::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; template<typename Expr2, typename S, typename D> result_type operator()(Expr2 const &e, S const &, D const &) const { expr_type const that = { proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) }; return proto_generator()(that); } }; template<typename Expr> struct deep_copy_impl<Expr, 5> { typedef typename base_expr< typename Expr::proto_domain , typename Expr::proto_tag , list5< typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type > >::type expr_type; typedef typename Expr::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; template<typename Expr2, typename S, typename D> result_type operator()(Expr2 const &e, S const &, D const &) const { expr_type const that = { proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) }; return proto_generator()(that); } }; template<typename Expr> struct deep_copy_impl<Expr, 6> { typedef typename base_expr< typename Expr::proto_domain , typename Expr::proto_tag , list6< typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type > >::type expr_type; typedef typename Expr::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; template<typename Expr2, typename S, typename D> result_type operator()(Expr2 const &e, S const &, D const &) const { expr_type const that = { proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) }; return proto_generator()(that); } }; template<typename Expr> struct deep_copy_impl<Expr, 7> { typedef typename base_expr< typename Expr::proto_domain , typename Expr::proto_tag , list7< typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type > >::type expr_type; typedef typename Expr::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; template<typename Expr2, typename S, typename D> result_type operator()(Expr2 const &e, S const &, D const &) const { expr_type const that = { proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) }; return proto_generator()(that); } }; template<typename Expr> struct deep_copy_impl<Expr, 8> { typedef typename base_expr< typename Expr::proto_domain , typename Expr::proto_tag , list8< typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type > >::type expr_type; typedef typename Expr::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; template<typename Expr2, typename S, typename D> result_type operator()(Expr2 const &e, S const &, D const &) const { expr_type const that = { proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7) }; return proto_generator()(that); } }; template<typename Expr> struct deep_copy_impl<Expr, 9> { typedef typename base_expr< typename Expr::proto_domain , typename Expr::proto_tag , list9< typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child8 >::type::proto_derived_expr >::result_type > >::type expr_type; typedef typename Expr::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; template<typename Expr2, typename S, typename D> result_type operator()(Expr2 const &e, S const &, D const &) const { expr_type const that = { proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7) , proto::deep_copy(e.proto_base().child8) }; return proto_generator()(that); } }; template<typename Expr> struct deep_copy_impl<Expr, 10> { typedef typename base_expr< typename Expr::proto_domain , typename Expr::proto_tag , list10< typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child8 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child9 >::type::proto_derived_expr >::result_type > >::type expr_type; typedef typename Expr::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; template<typename Expr2, typename S, typename D> result_type operator()(Expr2 const &e, S const &, D const &) const { expr_type const that = { proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7) , proto::deep_copy(e.proto_base().child8) , proto::deep_copy(e.proto_base().child9) }; return proto_generator()(that); } }; PK �J�[#�{�. �. ! detail/preprocessed/make_expr.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file make_expr.hpp /// Contains overloads of make_expr() free function. // // Copyright 2008 Eric Niebler. 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) template<typename Tag , typename A0 , typename A1> BOOST_FORCEINLINE typename lazy_disable_if< is_domain<A0> , result_of::make_expr< Tag , const A0 , const A1 > >::type const make_expr(const A0 &a0 , const A1 &a1) { return proto::detail::make_expr_< Tag , deduce_domain , const A0 , const A1 >()(a0 , a1); } template<typename Tag, typename Domain , typename C0 , typename C1> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const C0 , const C1 >::type const make_expr(const C0 &c0 , const C1 &c1) { return proto::detail::make_expr_< Tag , Domain , const C0 , const C1 >()(c0 , c1); } template<typename Tag , typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename lazy_disable_if< is_domain<A0> , result_of::make_expr< Tag , const A0 , const A1 , const A2 > >::type const make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2) { return proto::detail::make_expr_< Tag , deduce_domain , const A0 , const A1 , const A2 >()(a0 , a1 , a2); } template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const C0 , const C1 , const C2 >::type const make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2) { return proto::detail::make_expr_< Tag , Domain , const C0 , const C1 , const C2 >()(c0 , c1 , c2); } template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename lazy_disable_if< is_domain<A0> , result_of::make_expr< Tag , const A0 , const A1 , const A2 , const A3 > >::type const make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3) { return proto::detail::make_expr_< Tag , deduce_domain , const A0 , const A1 , const A2 , const A3 >()(a0 , a1 , a2 , a3); } template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const C0 , const C1 , const C2 , const C3 >::type const make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3) { return proto::detail::make_expr_< Tag , Domain , const C0 , const C1 , const C2 , const C3 >()(c0 , c1 , c2 , c3); } template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename lazy_disable_if< is_domain<A0> , result_of::make_expr< Tag , const A0 , const A1 , const A2 , const A3 , const A4 > >::type const make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4) { return proto::detail::make_expr_< Tag , deduce_domain , const A0 , const A1 , const A2 , const A3 , const A4 >()(a0 , a1 , a2 , a3 , a4); } template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const C0 , const C1 , const C2 , const C3 , const C4 >::type const make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4) { return proto::detail::make_expr_< Tag , Domain , const C0 , const C1 , const C2 , const C3 , const C4 >()(c0 , c1 , c2 , c3 , c4); } template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename lazy_disable_if< is_domain<A0> , result_of::make_expr< Tag , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > >::type const make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5) { return proto::detail::make_expr_< Tag , deduce_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >()(a0 , a1 , a2 , a3 , a4 , a5); } template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 >::type const make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5) { return proto::detail::make_expr_< Tag , Domain , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 >()(c0 , c1 , c2 , c3 , c4 , c5); } template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename lazy_disable_if< is_domain<A0> , result_of::make_expr< Tag , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > >::type const make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6) { return proto::detail::make_expr_< Tag , deduce_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >()(a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 >::type const make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6) { return proto::detail::make_expr_< Tag , Domain , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 >()(c0 , c1 , c2 , c3 , c4 , c5 , c6); } template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename lazy_disable_if< is_domain<A0> , result_of::make_expr< Tag , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > >::type const make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7) { return proto::detail::make_expr_< Tag , deduce_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 >::type const make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7) { return proto::detail::make_expr_< Tag , Domain , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7); } template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename lazy_disable_if< is_domain<A0> , result_of::make_expr< Tag , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > >::type const make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8) { return proto::detail::make_expr_< Tag , deduce_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 >::type const make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7 , const C8 &c8) { return proto::detail::make_expr_< Tag , Domain , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8); } template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> BOOST_FORCEINLINE typename lazy_disable_if< is_domain<A0> , result_of::make_expr< Tag , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9 > >::type const make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8 , const A9 &a9) { return proto::detail::make_expr_< Tag , deduce_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9 >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); } template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8 , typename C9> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 , const C9 >::type const make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7 , const C8 &c8 , const C9 &c9) { return proto::detail::make_expr_< Tag , Domain , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 , const C9 >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9); } PK �J�[E�� & detail/preprocessed/lambda_matches.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file lambda_matches.hpp /// Specializations of the lambda_matches template // // Copyright 2008 Eric Niebler. 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) template< template<typename , typename> class T , typename Expr0 , typename Expr1 , typename Grammar0 , typename Grammar1 > struct lambda_matches< T<Expr0 , Expr1> , T<Grammar0 , Grammar1> BOOST_PROTO_TEMPLATE_ARITY_PARAM(2) > : and_2< lambda_matches< Expr0 , Grammar0 >::value, lambda_matches< Expr1 , Grammar1 > > {}; template< template<typename , typename , typename> class T , typename Expr0 , typename Expr1 , typename Expr2 , typename Grammar0 , typename Grammar1 , typename Grammar2 > struct lambda_matches< T<Expr0 , Expr1 , Expr2> , T<Grammar0 , Grammar1 , Grammar2> BOOST_PROTO_TEMPLATE_ARITY_PARAM(3) > : and_3< lambda_matches< Expr0 , Grammar0 >::value, lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > > {}; template< template<typename , typename , typename , typename> class T , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 > struct lambda_matches< T<Expr0 , Expr1 , Expr2 , Expr3> , T<Grammar0 , Grammar1 , Grammar2 , Grammar3> BOOST_PROTO_TEMPLATE_ARITY_PARAM(4) > : and_4< lambda_matches< Expr0 , Grammar0 >::value, lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > > {}; template< template<typename , typename , typename , typename , typename> class T , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 > struct lambda_matches< T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4> , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4> BOOST_PROTO_TEMPLATE_ARITY_PARAM(5) > : and_5< lambda_matches< Expr0 , Grammar0 >::value, lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > > {}; template< template<typename , typename , typename , typename , typename , typename> class T , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 > struct lambda_matches< T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5> , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5> BOOST_PROTO_TEMPLATE_ARITY_PARAM(6) > : and_6< lambda_matches< Expr0 , Grammar0 >::value, lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > > {}; template< template<typename , typename , typename , typename , typename , typename , typename> class T , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 > struct lambda_matches< T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6> , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6> BOOST_PROTO_TEMPLATE_ARITY_PARAM(7) > : and_7< lambda_matches< Expr0 , Grammar0 >::value, lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > > {}; template< template<typename , typename , typename , typename , typename , typename , typename , typename> class T , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7 , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7 > struct lambda_matches< T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7> , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7> BOOST_PROTO_TEMPLATE_ARITY_PARAM(8) > : and_8< lambda_matches< Expr0 , Grammar0 >::value, lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 > > {}; template< template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class T , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7 , typename Expr8 , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7 , typename Grammar8 > struct lambda_matches< T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7 , Expr8> , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7 , Grammar8> BOOST_PROTO_TEMPLATE_ARITY_PARAM(9) > : and_9< lambda_matches< Expr0 , Grammar0 >::value, lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 > , lambda_matches< Expr8 , Grammar8 > > {}; template< template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class T , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7 , typename Expr8 , typename Expr9 , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7 , typename Grammar8 , typename Grammar9 > struct lambda_matches< T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7 , Expr8 , Expr9> , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7 , Grammar8 , Grammar9> BOOST_PROTO_TEMPLATE_ARITY_PARAM(10) > : and_10< lambda_matches< Expr0 , Grammar0 >::value, lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 > , lambda_matches< Expr8 , Grammar8 > , lambda_matches< Expr9 , Grammar9 > > {}; PK �J�[v�9/� /� detail/preprocessed/expr.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file expr.hpp /// Contains definition of expr\<\> class template. // // Copyright 2008 Eric Niebler. 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) template<typename Tag, typename Arg0> struct expr<Tag, term<Arg0>, 0> { typedef Tag proto_tag; static const long proto_arity_c = 0; typedef mpl::long_<0 > proto_arity; typedef expr proto_base_expr; typedef term<Arg0> proto_args; typedef basic_expr<Tag, proto_args, 0 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0> BOOST_FORCEINLINE static expr const make(A0 &a0) { return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0)); } template<typename A0> BOOST_FORCEINLINE static expr const make(A0 const &a0) { return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0)); } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) { proto::expr< proto::tag::assign , list2<expr &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) { proto::expr< proto::tag::assign , list2<expr &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) { proto::expr< proto::tag::subscript , list2<expr &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) { proto::expr< proto::tag::subscript , list2<expr &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr const &>, 1> const operator ()() const { proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; return that; } BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr &>, 1> const operator ()() { proto::expr<proto::tag::function, list1<expr &>, 1> that = {*this}; return that; } template<typename A0> BOOST_FORCEINLINE typename result_of::funop1< expr const , default_domain , const A0 >::type const operator ()(A0 const &a0) const { return result_of::funop1< expr const , default_domain , const A0 >::call(*this , a0); } template<typename A0> BOOST_FORCEINLINE typename result_of::funop1< expr , default_domain , const A0 >::type const operator ()(A0 const &a0) { return result_of::funop1< expr , default_domain , const A0 >::call(*this , a0); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename result_of::funop2< expr const , default_domain , const A0 , const A1 >::type const operator ()(A0 const &a0 , A1 const &a1) const { return result_of::funop2< expr const , default_domain , const A0 , const A1 >::call(*this , a0 , a1); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename result_of::funop2< expr , default_domain , const A0 , const A1 >::type const operator ()(A0 const &a0 , A1 const &a1) { return result_of::funop2< expr , default_domain , const A0 , const A1 >::call(*this , a0 , a1); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { return result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::call(*this , a0 , a1 , a2); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename result_of::funop3< expr , default_domain , const A0 , const A1 , const A2 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) { return result_of::funop3< expr , default_domain , const A0 , const A1 , const A2 >::call(*this , a0 , a1 , a2); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { return result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::call(*this , a0 , a1 , a2 , a3); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename result_of::funop4< expr , default_domain , const A0 , const A1 , const A2 , const A3 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) { return result_of::funop4< expr , default_domain , const A0 , const A1 , const A2 , const A3 >::call(*this , a0 , a1 , a2 , a3); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { return result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::call(*this , a0 , a1 , a2 , a3 , a4); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename result_of::funop5< expr , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) { return result_of::funop5< expr , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::call(*this , a0 , a1 , a2 , a3 , a4); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { return result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename result_of::funop6< expr , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) { return result_of::funop6< expr , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { return result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename result_of::funop7< expr , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) { return result_of::funop7< expr , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { return result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename result_of::funop8< expr , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) { return result_of::funop8< expr , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { return result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename result_of::funop9< expr , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) { return result_of::funop9< expr , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } }; template<typename Tag , typename Arg0> struct expr<Tag, list1<Arg0>, 1 > { typedef Tag proto_tag; static const long proto_arity_c = 1; typedef mpl::long_<1 > proto_arity; typedef expr proto_base_expr; typedef list1<Arg0> proto_args; typedef basic_expr<Tag, proto_args, 1 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0> BOOST_FORCEINLINE static expr const make(A0 const &a0) { expr that = {a0}; return that; } typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_; BOOST_FORCEINLINE operator address_of_hack_type_() const { return boost::addressof(this->child0); } BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr const &>, 1> const operator ()() const { proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; return that; } template<typename A0> BOOST_FORCEINLINE typename result_of::funop1< expr const , default_domain , const A0 >::type const operator ()(A0 const &a0) const { return result_of::funop1< expr const , default_domain , const A0 >::call(*this , a0); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename result_of::funop2< expr const , default_domain , const A0 , const A1 >::type const operator ()(A0 const &a0 , A1 const &a1) const { return result_of::funop2< expr const , default_domain , const A0 , const A1 >::call(*this , a0 , a1); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { return result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::call(*this , a0 , a1 , a2); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { return result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::call(*this , a0 , a1 , a2 , a3); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { return result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::call(*this , a0 , a1 , a2 , a3 , a4); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { return result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { return result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { return result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { return result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } }; template<typename Tag , typename Arg0 , typename Arg1> struct expr<Tag, list2<Arg0 , Arg1>, 2 > { typedef Tag proto_tag; static const long proto_arity_c = 2; typedef mpl::long_<2 > proto_arity; typedef expr proto_base_expr; typedef list2<Arg0 , Arg1> proto_args; typedef basic_expr<Tag, proto_args, 2 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1) { expr that = {a0 , a1}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr const &>, 1> const operator ()() const { proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; return that; } template<typename A0> BOOST_FORCEINLINE typename result_of::funop1< expr const , default_domain , const A0 >::type const operator ()(A0 const &a0) const { return result_of::funop1< expr const , default_domain , const A0 >::call(*this , a0); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename result_of::funop2< expr const , default_domain , const A0 , const A1 >::type const operator ()(A0 const &a0 , A1 const &a1) const { return result_of::funop2< expr const , default_domain , const A0 , const A1 >::call(*this , a0 , a1); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { return result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::call(*this , a0 , a1 , a2); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { return result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::call(*this , a0 , a1 , a2 , a3); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { return result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::call(*this , a0 , a1 , a2 , a3 , a4); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { return result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { return result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { return result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { return result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2> struct expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3 > { typedef Tag proto_tag; static const long proto_arity_c = 3; typedef mpl::long_<3 > proto_arity; typedef expr proto_base_expr; typedef list3<Arg0 , Arg1 , Arg2> proto_args; typedef basic_expr<Tag, proto_args, 3 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2) { expr that = {a0 , a1 , a2}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr const &>, 1> const operator ()() const { proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; return that; } template<typename A0> BOOST_FORCEINLINE typename result_of::funop1< expr const , default_domain , const A0 >::type const operator ()(A0 const &a0) const { return result_of::funop1< expr const , default_domain , const A0 >::call(*this , a0); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename result_of::funop2< expr const , default_domain , const A0 , const A1 >::type const operator ()(A0 const &a0 , A1 const &a1) const { return result_of::funop2< expr const , default_domain , const A0 , const A1 >::call(*this , a0 , a1); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { return result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::call(*this , a0 , a1 , a2); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { return result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::call(*this , a0 , a1 , a2 , a3); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { return result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::call(*this , a0 , a1 , a2 , a3 , a4); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { return result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { return result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { return result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { return result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3> struct expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4 > { typedef Tag proto_tag; static const long proto_arity_c = 4; typedef mpl::long_<4 > proto_arity; typedef expr proto_base_expr; typedef list4<Arg0 , Arg1 , Arg2 , Arg3> proto_args; typedef basic_expr<Tag, proto_args, 4 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) { expr that = {a0 , a1 , a2 , a3}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr const &>, 1> const operator ()() const { proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; return that; } template<typename A0> BOOST_FORCEINLINE typename result_of::funop1< expr const , default_domain , const A0 >::type const operator ()(A0 const &a0) const { return result_of::funop1< expr const , default_domain , const A0 >::call(*this , a0); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename result_of::funop2< expr const , default_domain , const A0 , const A1 >::type const operator ()(A0 const &a0 , A1 const &a1) const { return result_of::funop2< expr const , default_domain , const A0 , const A1 >::call(*this , a0 , a1); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { return result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::call(*this , a0 , a1 , a2); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { return result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::call(*this , a0 , a1 , a2 , a3); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { return result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::call(*this , a0 , a1 , a2 , a3 , a4); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { return result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { return result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { return result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { return result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4> struct expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5 > { typedef Tag proto_tag; static const long proto_arity_c = 5; typedef mpl::long_<5 > proto_arity; typedef expr proto_base_expr; typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> proto_args; typedef basic_expr<Tag, proto_args, 5 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) { expr that = {a0 , a1 , a2 , a3 , a4}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr const &>, 1> const operator ()() const { proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; return that; } template<typename A0> BOOST_FORCEINLINE typename result_of::funop1< expr const , default_domain , const A0 >::type const operator ()(A0 const &a0) const { return result_of::funop1< expr const , default_domain , const A0 >::call(*this , a0); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename result_of::funop2< expr const , default_domain , const A0 , const A1 >::type const operator ()(A0 const &a0 , A1 const &a1) const { return result_of::funop2< expr const , default_domain , const A0 , const A1 >::call(*this , a0 , a1); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { return result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::call(*this , a0 , a1 , a2); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { return result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::call(*this , a0 , a1 , a2 , a3); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { return result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::call(*this , a0 , a1 , a2 , a3 , a4); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { return result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { return result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { return result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { return result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5> struct expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 > { typedef Tag proto_tag; static const long proto_arity_c = 6; typedef mpl::long_<6 > proto_arity; typedef expr proto_base_expr; typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args; typedef basic_expr<Tag, proto_args, 6 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) { expr that = {a0 , a1 , a2 , a3 , a4 , a5}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr const &>, 1> const operator ()() const { proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; return that; } template<typename A0> BOOST_FORCEINLINE typename result_of::funop1< expr const , default_domain , const A0 >::type const operator ()(A0 const &a0) const { return result_of::funop1< expr const , default_domain , const A0 >::call(*this , a0); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename result_of::funop2< expr const , default_domain , const A0 , const A1 >::type const operator ()(A0 const &a0 , A1 const &a1) const { return result_of::funop2< expr const , default_domain , const A0 , const A1 >::call(*this , a0 , a1); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { return result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::call(*this , a0 , a1 , a2); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { return result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::call(*this , a0 , a1 , a2 , a3); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { return result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::call(*this , a0 , a1 , a2 , a3 , a4); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { return result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { return result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { return result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { return result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6> struct expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 > { typedef Tag proto_tag; static const long proto_arity_c = 7; typedef mpl::long_<7 > proto_arity; typedef expr proto_base_expr; typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args; typedef basic_expr<Tag, proto_args, 7 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) { expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr const &>, 1> const operator ()() const { proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; return that; } template<typename A0> BOOST_FORCEINLINE typename result_of::funop1< expr const , default_domain , const A0 >::type const operator ()(A0 const &a0) const { return result_of::funop1< expr const , default_domain , const A0 >::call(*this , a0); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename result_of::funop2< expr const , default_domain , const A0 , const A1 >::type const operator ()(A0 const &a0 , A1 const &a1) const { return result_of::funop2< expr const , default_domain , const A0 , const A1 >::call(*this , a0 , a1); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { return result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::call(*this , a0 , a1 , a2); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { return result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::call(*this , a0 , a1 , a2 , a3); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { return result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::call(*this , a0 , a1 , a2 , a3 , a4); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { return result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { return result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { return result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { return result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7> struct expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 > { typedef Tag proto_tag; static const long proto_arity_c = 8; typedef mpl::long_<8 > proto_arity; typedef expr proto_base_expr; typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args; typedef basic_expr<Tag, proto_args, 8 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) { expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr const &>, 1> const operator ()() const { proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; return that; } template<typename A0> BOOST_FORCEINLINE typename result_of::funop1< expr const , default_domain , const A0 >::type const operator ()(A0 const &a0) const { return result_of::funop1< expr const , default_domain , const A0 >::call(*this , a0); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename result_of::funop2< expr const , default_domain , const A0 , const A1 >::type const operator ()(A0 const &a0 , A1 const &a1) const { return result_of::funop2< expr const , default_domain , const A0 , const A1 >::call(*this , a0 , a1); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { return result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::call(*this , a0 , a1 , a2); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { return result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::call(*this , a0 , a1 , a2 , a3); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { return result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::call(*this , a0 , a1 , a2 , a3 , a4); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { return result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { return result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { return result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { return result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8> struct expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 > { typedef Tag proto_tag; static const long proto_arity_c = 9; typedef mpl::long_<9 > proto_arity; typedef expr proto_base_expr; typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args; typedef basic_expr<Tag, proto_args, 9 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) { expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr const &>, 1> const operator ()() const { proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; return that; } template<typename A0> BOOST_FORCEINLINE typename result_of::funop1< expr const , default_domain , const A0 >::type const operator ()(A0 const &a0) const { return result_of::funop1< expr const , default_domain , const A0 >::call(*this , a0); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename result_of::funop2< expr const , default_domain , const A0 , const A1 >::type const operator ()(A0 const &a0 , A1 const &a1) const { return result_of::funop2< expr const , default_domain , const A0 , const A1 >::call(*this , a0 , a1); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { return result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::call(*this , a0 , a1 , a2); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { return result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::call(*this , a0 , a1 , a2 , a3); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { return result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::call(*this , a0 , a1 , a2 , a3 , a4); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { return result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { return result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { return result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { return result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9> struct expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 > { typedef Tag proto_tag; static const long proto_arity_c = 10; typedef mpl::long_<10 > proto_arity; typedef expr proto_base_expr; typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args; typedef basic_expr<Tag, proto_args, 10 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) { expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr const &>, 1> const operator ()() const { proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; return that; } template<typename A0> BOOST_FORCEINLINE typename result_of::funop1< expr const , default_domain , const A0 >::type const operator ()(A0 const &a0) const { return result_of::funop1< expr const , default_domain , const A0 >::call(*this , a0); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename result_of::funop2< expr const , default_domain , const A0 , const A1 >::type const operator ()(A0 const &a0 , A1 const &a1) const { return result_of::funop2< expr const , default_domain , const A0 , const A1 >::call(*this , a0 , a1); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { return result_of::funop3< expr const , default_domain , const A0 , const A1 , const A2 >::call(*this , a0 , a1 , a2); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { return result_of::funop4< expr const , default_domain , const A0 , const A1 , const A2 , const A3 >::call(*this , a0 , a1 , a2 , a3); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { return result_of::funop5< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::call(*this , a0 , a1 , a2 , a3 , a4); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { return result_of::funop6< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { return result_of::funop7< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { return result_of::funop8< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { return result_of::funop9< expr const , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } }; PK �J�[��%��2 �2 , detail/preprocessed/poly_function_traits.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// // poly_function_traits.hpp // Contains specializations of poly_function_traits and as_mono_function // // Copyright 2008 Eric Niebler. 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) template<typename PolyFun , typename A0> struct poly_function_traits<PolyFun, PolyFun(A0), mpl::size_t<sizeof(poly_function_t)> > { typedef typename PolyFun::template impl<const A0> function_type; typedef typename function_type::result_type result_type; }; template<typename PolyFun , typename A0> struct as_mono_function_impl<PolyFun(A0), true> { typedef typename PolyFun::template impl<const A0> type; }; template<typename PolyFun , typename A0> struct as_mono_function_impl<PolyFun(A0), false> { typedef PolyFun type; }; template<typename PolyFun , typename A0> struct as_mono_function<PolyFun(A0)> : as_mono_function_impl<PolyFun(A0), is_poly_function<PolyFun>::value> {}; template<typename PolyFun , typename A0 , typename A1> struct poly_function_traits<PolyFun, PolyFun(A0 , A1), mpl::size_t<sizeof(poly_function_t)> > { typedef typename PolyFun::template impl<const A0 , const A1> function_type; typedef typename function_type::result_type result_type; }; template<typename PolyFun , typename A0 , typename A1> struct as_mono_function_impl<PolyFun(A0 , A1), true> { typedef typename PolyFun::template impl<const A0 , const A1> type; }; template<typename PolyFun , typename A0 , typename A1> struct as_mono_function_impl<PolyFun(A0 , A1), false> { typedef PolyFun type; }; template<typename PolyFun , typename A0 , typename A1> struct as_mono_function<PolyFun(A0 , A1)> : as_mono_function_impl<PolyFun(A0 , A1), is_poly_function<PolyFun>::value> {}; template<typename PolyFun , typename A0 , typename A1 , typename A2> struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2), mpl::size_t<sizeof(poly_function_t)> > { typedef typename PolyFun::template impl<const A0 , const A1 , const A2> function_type; typedef typename function_type::result_type result_type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2> struct as_mono_function_impl<PolyFun(A0 , A1 , A2), true> { typedef typename PolyFun::template impl<const A0 , const A1 , const A2> type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2> struct as_mono_function_impl<PolyFun(A0 , A1 , A2), false> { typedef PolyFun type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2> struct as_mono_function<PolyFun(A0 , A1 , A2)> : as_mono_function_impl<PolyFun(A0 , A1 , A2), is_poly_function<PolyFun>::value> {}; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3> struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3), mpl::size_t<sizeof(poly_function_t)> > { typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3> function_type; typedef typename function_type::result_type result_type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3> struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), true> { typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3> type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3> struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), false> { typedef PolyFun type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3> struct as_mono_function<PolyFun(A0 , A1 , A2 , A3)> : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), is_poly_function<PolyFun>::value> {}; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4), mpl::size_t<sizeof(poly_function_t)> > { typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4> function_type; typedef typename function_type::result_type result_type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), true> { typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4> type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), false> { typedef PolyFun type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4)> : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), is_poly_function<PolyFun>::value> {}; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5), mpl::size_t<sizeof(poly_function_t)> > { typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5> function_type; typedef typename function_type::result_type result_type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), true> { typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5> type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), false> { typedef PolyFun type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5)> : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), is_poly_function<PolyFun>::value> {}; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), mpl::size_t<sizeof(poly_function_t)> > { typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6> function_type; typedef typename function_type::result_type result_type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), true> { typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6> type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), false> { typedef PolyFun type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), is_poly_function<PolyFun>::value> {}; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), mpl::size_t<sizeof(poly_function_t)> > { typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7> function_type; typedef typename function_type::result_type result_type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), true> { typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7> type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), false> { typedef PolyFun type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), is_poly_function<PolyFun>::value> {}; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), mpl::size_t<sizeof(poly_function_t)> > { typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8> function_type; typedef typename function_type::result_type result_type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), true> { typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8> type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), false> { typedef PolyFun type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), is_poly_function<PolyFun>::value> {}; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), mpl::size_t<sizeof(poly_function_t)> > { typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9> function_type; typedef typename function_type::result_type result_type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), true> { typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9> type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), false> { typedef PolyFun type; }; template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), is_poly_function<PolyFun>::value> {}; PK �J�[4� ' detail/preprocessed/deduce_domain_n.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// // deduce_domain_n.hpp // Definitions of common_domain[n] and deduce_domain[n] class templates. // // Copyright 2008 Eric Niebler. 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) template<typename A0 , typename A1 , typename A2> struct common_domain3 { typedef A0 common1; typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef common3 type; BOOST_PROTO_ASSERT_VALID_DOMAIN(type); }; template<typename E0 , typename E1 , typename E2> struct deduce_domain3 : common_domain3< typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type > {}; template<typename A0 , typename A1 , typename A2 , typename A3> struct common_domain4 { typedef A0 common1; typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef common4 type; BOOST_PROTO_ASSERT_VALID_DOMAIN(type); }; template<typename E0 , typename E1 , typename E2 , typename E3> struct deduce_domain4 : common_domain4< typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type > {}; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct common_domain5 { typedef A0 common1; typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef common5 type; BOOST_PROTO_ASSERT_VALID_DOMAIN(type); }; template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4> struct deduce_domain5 : common_domain5< typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type > {}; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct common_domain6 { typedef A0 common1; typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef common6 type; BOOST_PROTO_ASSERT_VALID_DOMAIN(type); }; template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5> struct deduce_domain6 : common_domain6< typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type > {}; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct common_domain7 { typedef A0 common1; typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef common7 type; BOOST_PROTO_ASSERT_VALID_DOMAIN(type); }; template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6> struct deduce_domain7 : common_domain7< typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type > {}; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct common_domain8 { typedef A0 common1; typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8; typedef common8 type; BOOST_PROTO_ASSERT_VALID_DOMAIN(type); }; template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7> struct deduce_domain8 : common_domain8< typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type > {}; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct common_domain9 { typedef A0 common1; typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8; typedef typename common_domain2<common8, A8>::type common9; typedef common9 type; BOOST_PROTO_ASSERT_VALID_DOMAIN(type); }; template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7 , typename E8> struct deduce_domain9 : common_domain9< typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type , typename domain_of<E8 >::type > {}; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct common_domain10 { typedef A0 common1; typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8; typedef typename common_domain2<common8, A8>::type common9; typedef typename common_domain2<common9, A9>::type common10; typedef common10 type; BOOST_PROTO_ASSERT_VALID_DOMAIN(type); }; template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7 , typename E8 , typename E9> struct deduce_domain10 : common_domain10< typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type , typename domain_of<E8 >::type , typename domain_of<E9 >::type > {}; PK �J�[xu��^� ^� detail/preprocessed/matches_.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file matches_.hpp /// Definitions of matches_ specializations // // Copyright 2008 Eric Niebler. 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) template<typename Expr, typename BasicExpr , typename G0 , typename G1> struct matches_<Expr, BasicExpr, proto::or_<G0 , G1> > : or_2< matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, Expr, BasicExpr , G0 , G1 > {}; template<typename Expr, typename BasicExpr, typename G0 , typename G1> struct matches_<Expr, BasicExpr, proto::and_<G0 , G1> > : detail::and_2< matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, matches_< Expr , BasicExpr , typename G1::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 2>, proto::basic_expr<Tag, Args2, 2> > : and_2< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 2>, proto::basic_expr<proto::_, Args2, 2> > : and_2< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2> struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2> > : or_3< matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, Expr, BasicExpr , G0 , G1 , G2 > {}; template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2> struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2> > : detail::and_3< matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 3>, proto::basic_expr<Tag, Args2, 3> > : and_3< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 3>, proto::basic_expr<proto::_, Args2, 3> > : and_3< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3> struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3> > : or_4< matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, Expr, BasicExpr , G0 , G1 , G2 , G3 > {}; template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3> struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3> > : detail::and_4< matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 4>, proto::basic_expr<Tag, Args2, 4> > : and_4< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 4>, proto::basic_expr<proto::_, Args2, 4> > : and_4< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4> struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4> > : or_5< matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 > {}; template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4> struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4> > : detail::and_5< matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 5>, proto::basic_expr<Tag, Args2, 5> > : and_5< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 5>, proto::basic_expr<proto::_, Args2, 5> > : and_5< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5> struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5> > : or_6< matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 > {}; template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5> struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5> > : detail::and_6< matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 6>, proto::basic_expr<Tag, Args2, 6> > : and_6< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 6>, proto::basic_expr<proto::_, Args2, 6> > : and_6< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6> struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6> > : or_7< matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 > {}; template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6> struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6> > : detail::and_7< matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 7>, proto::basic_expr<Tag, Args2, 7> > : and_7< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 7>, proto::basic_expr<proto::_, Args2, 7> > : and_7< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7> struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7> > : or_8< matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 > {}; template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7> struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7> > : detail::and_8< matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 8>, proto::basic_expr<Tag, Args2, 8> > : and_8< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 8>, proto::basic_expr<proto::_, Args2, 8> > : and_8< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8> struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8> > : or_9< matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 > {}; template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8> struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8> > : detail::and_9< matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar > , matches_< Expr , BasicExpr , typename G8::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 9>, proto::basic_expr<Tag, Args2, 9> > : and_9< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 9>, proto::basic_expr<proto::_, Args2, 9> > : and_9< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > > {}; template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9> struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> > : or_10< matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9 > {}; template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9> struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> > : detail::and_10< matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar > , matches_< Expr , BasicExpr , typename G8::proto_grammar > , matches_< Expr , BasicExpr , typename G9::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 10>, proto::basic_expr<Tag, Args2, 10> > : and_10< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child9>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child9>::value_type::proto_grammar , typename Args2::child9::proto_grammar > > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, 10>, proto::basic_expr<proto::_, Args2, 10> > : and_10< matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child9>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child9>::value_type::proto_grammar , typename Args2::child9::proto_grammar > > {}; PK �J�[�oR^;3 ;3 % detail/preprocessed/extends_funop.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file extends_funop.hpp /// Definitions for extends\<\>::operator() // // Copyright 2008 Eric Niebler. 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) template<typename Sig> struct result { typedef typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop< Sig , proto_derived_expr , proto_domain >::type ) >::type const type; }; BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr const , proto_domain >::type ) >::type const operator ()() const { typedef boost::proto::result_of::funop0< proto_derived_expr const , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) ) ); } BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr , proto_domain >::type ) >::type const operator ()() { typedef boost::proto::result_of::funop0< proto_derived_expr , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) ) ); } template<typename A0> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) const { typedef boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 ) ); } template<typename A0> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) { typedef boost::proto::result_of::funop1< proto_derived_expr , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 ) ); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) const { typedef boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 ) ); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) { typedef boost::proto::result_of::funop2< proto_derived_expr , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 ) ); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { typedef boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 ) ); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) { typedef boost::proto::result_of::funop3< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { typedef boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) { typedef boost::proto::result_of::funop4< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { typedef boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) { typedef boost::proto::result_of::funop5< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { typedef boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) { typedef boost::proto::result_of::funop6< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { typedef boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) { typedef boost::proto::result_of::funop7< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { typedef boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) { typedef boost::proto::result_of::funop8< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { typedef boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) { typedef boost::proto::result_of::funop9< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); } PK �J�[(Y���� �� % detail/preprocessed/expr_variadic.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file expr_variadic.hpp /// Contains definition of expr\<\> class template. // // Copyright 2008 Eric Niebler. 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) template<typename Tag, typename Arg0> struct expr<Tag, term<Arg0>, 0> { typedef Tag proto_tag; static const long proto_arity_c = 0; typedef mpl::long_<0 > proto_arity; typedef expr proto_base_expr; typedef term<Arg0> proto_args; typedef basic_expr<Tag, proto_args, 0 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0> BOOST_FORCEINLINE static expr const make(A0 &a0) { return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0)); } template<typename A0> BOOST_FORCEINLINE static expr const make(A0 const &a0) { return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0)); } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) { proto::expr< proto::tag::assign , list2<expr &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) { proto::expr< proto::tag::assign , list2<expr &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) { proto::expr< proto::tag::subscript , list2<expr &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) { proto::expr< proto::tag::subscript , list2<expr &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr const(A const &...) , expr , default_domain >::type const operator ()(A const &... a) const { return result_of::funop< expr const(A const &...) , expr , default_domain >::call(*this, a...); } template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr(A const &...) , expr , default_domain >::type const operator ()(A const &... a) { return result_of::funop< expr(A const &...) , expr , default_domain >::call(*this, a...); } }; template<typename Tag , typename Arg0> struct expr<Tag, list1<Arg0>, 1 > { typedef Tag proto_tag; static const long proto_arity_c = 1; typedef mpl::long_<1 > proto_arity; typedef expr proto_base_expr; typedef list1<Arg0> proto_args; typedef basic_expr<Tag, proto_args, 1 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0> BOOST_FORCEINLINE static expr const make(A0 const &a0) { expr that = {a0}; return that; } typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_; BOOST_FORCEINLINE operator address_of_hack_type_() const { return boost::addressof(this->child0); } BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr const(A const &...) , expr , default_domain >::type const operator ()(A const &... a) const { return result_of::funop< expr const(A const &...) , expr , default_domain >::call(*this, a...); } }; template<typename Tag , typename Arg0 , typename Arg1> struct expr<Tag, list2<Arg0 , Arg1>, 2 > { typedef Tag proto_tag; static const long proto_arity_c = 2; typedef mpl::long_<2 > proto_arity; typedef expr proto_base_expr; typedef list2<Arg0 , Arg1> proto_args; typedef basic_expr<Tag, proto_args, 2 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1) { expr that = {a0 , a1}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr const(A const &...) , expr , default_domain >::type const operator ()(A const &... a) const { return result_of::funop< expr const(A const &...) , expr , default_domain >::call(*this, a...); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2> struct expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3 > { typedef Tag proto_tag; static const long proto_arity_c = 3; typedef mpl::long_<3 > proto_arity; typedef expr proto_base_expr; typedef list3<Arg0 , Arg1 , Arg2> proto_args; typedef basic_expr<Tag, proto_args, 3 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2) { expr that = {a0 , a1 , a2}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr const(A const &...) , expr , default_domain >::type const operator ()(A const &... a) const { return result_of::funop< expr const(A const &...) , expr , default_domain >::call(*this, a...); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3> struct expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4 > { typedef Tag proto_tag; static const long proto_arity_c = 4; typedef mpl::long_<4 > proto_arity; typedef expr proto_base_expr; typedef list4<Arg0 , Arg1 , Arg2 , Arg3> proto_args; typedef basic_expr<Tag, proto_args, 4 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) { expr that = {a0 , a1 , a2 , a3}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr const(A const &...) , expr , default_domain >::type const operator ()(A const &... a) const { return result_of::funop< expr const(A const &...) , expr , default_domain >::call(*this, a...); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4> struct expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5 > { typedef Tag proto_tag; static const long proto_arity_c = 5; typedef mpl::long_<5 > proto_arity; typedef expr proto_base_expr; typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> proto_args; typedef basic_expr<Tag, proto_args, 5 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) { expr that = {a0 , a1 , a2 , a3 , a4}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr const(A const &...) , expr , default_domain >::type const operator ()(A const &... a) const { return result_of::funop< expr const(A const &...) , expr , default_domain >::call(*this, a...); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5> struct expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 > { typedef Tag proto_tag; static const long proto_arity_c = 6; typedef mpl::long_<6 > proto_arity; typedef expr proto_base_expr; typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args; typedef basic_expr<Tag, proto_args, 6 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) { expr that = {a0 , a1 , a2 , a3 , a4 , a5}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr const(A const &...) , expr , default_domain >::type const operator ()(A const &... a) const { return result_of::funop< expr const(A const &...) , expr , default_domain >::call(*this, a...); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6> struct expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 > { typedef Tag proto_tag; static const long proto_arity_c = 7; typedef mpl::long_<7 > proto_arity; typedef expr proto_base_expr; typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args; typedef basic_expr<Tag, proto_args, 7 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) { expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr const(A const &...) , expr , default_domain >::type const operator ()(A const &... a) const { return result_of::funop< expr const(A const &...) , expr , default_domain >::call(*this, a...); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7> struct expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 > { typedef Tag proto_tag; static const long proto_arity_c = 8; typedef mpl::long_<8 > proto_arity; typedef expr proto_base_expr; typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args; typedef basic_expr<Tag, proto_args, 8 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef void proto_child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) { expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr const(A const &...) , expr , default_domain >::type const operator ()(A const &... a) const { return result_of::funop< expr const(A const &...) , expr , default_domain >::call(*this, a...); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8> struct expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 > { typedef Tag proto_tag; static const long proto_arity_c = 9; typedef mpl::long_<9 > proto_arity; typedef expr proto_base_expr; typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args; typedef basic_expr<Tag, proto_args, 9 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef void proto_child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) { expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr const(A const &...) , expr , default_domain >::type const operator ()(A const &... a) const { return result_of::funop< expr const(A const &...) , expr , default_domain >::call(*this, a...); } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9> struct expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 > { typedef Tag proto_tag; static const long proto_arity_c = 10; typedef mpl::long_<10 > proto_arity; typedef expr proto_base_expr; typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args; typedef basic_expr<Tag, proto_args, 10 > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9; BOOST_FORCEINLINE expr const &proto_base() const { return *this; } BOOST_FORCEINLINE expr &proto_base() { return *this; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> BOOST_FORCEINLINE static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) { expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9}; return that; } typedef detail::not_a_valid_type address_of_hack_type_; BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr const(A const &...) , expr , default_domain >::type const operator ()(A const &... a) const { return result_of::funop< expr const(A const &...) , expr , default_domain >::call(*this, a...); } }; PK �J�[�\���� �� detail/preprocessed/traits.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file traits.hpp /// Definitions of proto::function, proto::nary_expr and proto::result_of::child_c // // Copyright 2008 Eric Niebler. 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) namespace result_of { template<typename Expr> struct child_c<Expr, 0> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child0 value_type; typedef typename detail::expr_traits<typename Expr::proto_child0>::value_type type; }; template<typename Expr> struct child_c<Expr &, 0> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child0 value_type; typedef typename detail::expr_traits<typename Expr::proto_child0>::reference type; BOOST_FORCEINLINE static type call(Expr &e) { return e.proto_base().child0; } }; template<typename Expr> struct child_c<Expr const &, 0> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child0 value_type; typedef typename detail::expr_traits<typename Expr::proto_child0>::const_reference type; BOOST_FORCEINLINE static type call(Expr const &e) { return e.proto_base().child0; } }; } template<typename A0> struct function < A0 , void , void , void , void , void , void , void , void , void > : proto::transform< function< A0 , void , void , void , void , void , void , void , void , void > , int > { typedef proto::expr<proto::tag::function, list1<A0>, 1> type; typedef proto::basic_expr<proto::tag::function, list1<A0>, 1> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> {}; typedef proto::tag::function proto_tag; typedef A0 proto_child0; typedef detail::if_vararg<A0> proto_child1; typedef detail::if_vararg<A0> proto_child2; typedef detail::if_vararg<A0> proto_child3; typedef detail::if_vararg<A0> proto_child4; typedef detail::if_vararg<A0> proto_child5; typedef detail::if_vararg<A0> proto_child6; typedef detail::if_vararg<A0> proto_child7; typedef detail::if_vararg<A0> proto_child8; typedef detail::if_vararg<A0> proto_child9; }; template<typename Tag , typename A0> struct nary_expr < Tag , A0 , void , void , void , void , void , void , void , void , void > : proto::transform< nary_expr< Tag , A0 , void , void , void , void , void , void , void , void , void > , int > { typedef proto::expr<Tag, list1<A0>, 1> type; typedef proto::basic_expr<Tag, list1<A0>, 1> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> {}; typedef Tag proto_tag; typedef A0 proto_child0; typedef detail::if_vararg<A0> proto_child1; typedef detail::if_vararg<A0> proto_child2; typedef detail::if_vararg<A0> proto_child3; typedef detail::if_vararg<A0> proto_child4; typedef detail::if_vararg<A0> proto_child5; typedef detail::if_vararg<A0> proto_child6; typedef detail::if_vararg<A0> proto_child7; typedef detail::if_vararg<A0> proto_child8; typedef detail::if_vararg<A0> proto_child9; }; namespace detail { template< template<typename> class T , typename A0 > struct is_callable_<T<A0> BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)> : is_same<A0, callable> {}; } namespace result_of { template<typename Expr> struct child_c<Expr, 1> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child1 value_type; typedef typename detail::expr_traits<typename Expr::proto_child1>::value_type type; }; template<typename Expr> struct child_c<Expr &, 1> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child1 value_type; typedef typename detail::expr_traits<typename Expr::proto_child1>::reference type; BOOST_FORCEINLINE static type call(Expr &e) { return e.proto_base().child1; } }; template<typename Expr> struct child_c<Expr const &, 1> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child1 value_type; typedef typename detail::expr_traits<typename Expr::proto_child1>::const_reference type; BOOST_FORCEINLINE static type call(Expr const &e) { return e.proto_base().child1; } }; } template<typename A0 , typename A1> struct function < A0 , A1 , void , void , void , void , void , void , void , void > : proto::transform< function< A0 , A1 , void , void , void , void , void , void , void , void > , int > { typedef proto::expr<proto::tag::function, list2<A0 , A1>, 2> type; typedef proto::basic_expr<proto::tag::function, list2<A0 , A1>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> {}; typedef proto::tag::function proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef detail::if_vararg<A1> proto_child2; typedef detail::if_vararg<A1> proto_child3; typedef detail::if_vararg<A1> proto_child4; typedef detail::if_vararg<A1> proto_child5; typedef detail::if_vararg<A1> proto_child6; typedef detail::if_vararg<A1> proto_child7; typedef detail::if_vararg<A1> proto_child8; typedef detail::if_vararg<A1> proto_child9; }; template<typename Tag , typename A0 , typename A1> struct nary_expr < Tag , A0 , A1 , void , void , void , void , void , void , void , void > : proto::transform< nary_expr< Tag , A0 , A1 , void , void , void , void , void , void , void , void > , int > { typedef proto::expr<Tag, list2<A0 , A1>, 2> type; typedef proto::basic_expr<Tag, list2<A0 , A1>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> {}; typedef Tag proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef detail::if_vararg<A1> proto_child2; typedef detail::if_vararg<A1> proto_child3; typedef detail::if_vararg<A1> proto_child4; typedef detail::if_vararg<A1> proto_child5; typedef detail::if_vararg<A1> proto_child6; typedef detail::if_vararg<A1> proto_child7; typedef detail::if_vararg<A1> proto_child8; typedef detail::if_vararg<A1> proto_child9; }; namespace detail { template< template<typename , typename> class T , typename A0 , typename A1 > struct is_callable_<T<A0 , A1> BOOST_PROTO_TEMPLATE_ARITY_PARAM(2)> : is_same<A1, callable> {}; } namespace result_of { template<typename Expr> struct child_c<Expr, 2> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child2 value_type; typedef typename detail::expr_traits<typename Expr::proto_child2>::value_type type; }; template<typename Expr> struct child_c<Expr &, 2> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child2 value_type; typedef typename detail::expr_traits<typename Expr::proto_child2>::reference type; BOOST_FORCEINLINE static type call(Expr &e) { return e.proto_base().child2; } }; template<typename Expr> struct child_c<Expr const &, 2> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child2 value_type; typedef typename detail::expr_traits<typename Expr::proto_child2>::const_reference type; BOOST_FORCEINLINE static type call(Expr const &e) { return e.proto_base().child2; } }; } template<typename A0 , typename A1 , typename A2> struct function < A0 , A1 , A2 , void , void , void , void , void , void , void > : proto::transform< function< A0 , A1 , A2 , void , void , void , void , void , void , void > , int > { typedef proto::expr<proto::tag::function, list3<A0 , A1 , A2>, 3> type; typedef proto::basic_expr<proto::tag::function, list3<A0 , A1 , A2>, 3> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> {}; typedef proto::tag::function proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef detail::if_vararg<A2> proto_child3; typedef detail::if_vararg<A2> proto_child4; typedef detail::if_vararg<A2> proto_child5; typedef detail::if_vararg<A2> proto_child6; typedef detail::if_vararg<A2> proto_child7; typedef detail::if_vararg<A2> proto_child8; typedef detail::if_vararg<A2> proto_child9; }; template<typename Tag , typename A0 , typename A1 , typename A2> struct nary_expr < Tag , A0 , A1 , A2 , void , void , void , void , void , void , void > : proto::transform< nary_expr< Tag , A0 , A1 , A2 , void , void , void , void , void , void , void > , int > { typedef proto::expr<Tag, list3<A0 , A1 , A2>, 3> type; typedef proto::basic_expr<Tag, list3<A0 , A1 , A2>, 3> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> {}; typedef Tag proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef detail::if_vararg<A2> proto_child3; typedef detail::if_vararg<A2> proto_child4; typedef detail::if_vararg<A2> proto_child5; typedef detail::if_vararg<A2> proto_child6; typedef detail::if_vararg<A2> proto_child7; typedef detail::if_vararg<A2> proto_child8; typedef detail::if_vararg<A2> proto_child9; }; namespace detail { template< template<typename , typename , typename> class T , typename A0 , typename A1 , typename A2 > struct is_callable_<T<A0 , A1 , A2> BOOST_PROTO_TEMPLATE_ARITY_PARAM(3)> : is_same<A2, callable> {}; } namespace result_of { template<typename Expr> struct child_c<Expr, 3> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child3 value_type; typedef typename detail::expr_traits<typename Expr::proto_child3>::value_type type; }; template<typename Expr> struct child_c<Expr &, 3> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child3 value_type; typedef typename detail::expr_traits<typename Expr::proto_child3>::reference type; BOOST_FORCEINLINE static type call(Expr &e) { return e.proto_base().child3; } }; template<typename Expr> struct child_c<Expr const &, 3> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child3 value_type; typedef typename detail::expr_traits<typename Expr::proto_child3>::const_reference type; BOOST_FORCEINLINE static type call(Expr const &e) { return e.proto_base().child3; } }; } template<typename A0 , typename A1 , typename A2 , typename A3> struct function < A0 , A1 , A2 , A3 , void , void , void , void , void , void > : proto::transform< function< A0 , A1 , A2 , A3 , void , void , void , void , void , void > , int > { typedef proto::expr<proto::tag::function, list4<A0 , A1 , A2 , A3>, 4> type; typedef proto::basic_expr<proto::tag::function, list4<A0 , A1 , A2 , A3>, 4> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> {}; typedef proto::tag::function proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef detail::if_vararg<A3> proto_child4; typedef detail::if_vararg<A3> proto_child5; typedef detail::if_vararg<A3> proto_child6; typedef detail::if_vararg<A3> proto_child7; typedef detail::if_vararg<A3> proto_child8; typedef detail::if_vararg<A3> proto_child9; }; template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3> struct nary_expr < Tag , A0 , A1 , A2 , A3 , void , void , void , void , void , void > : proto::transform< nary_expr< Tag , A0 , A1 , A2 , A3 , void , void , void , void , void , void > , int > { typedef proto::expr<Tag, list4<A0 , A1 , A2 , A3>, 4> type; typedef proto::basic_expr<Tag, list4<A0 , A1 , A2 , A3>, 4> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> {}; typedef Tag proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef detail::if_vararg<A3> proto_child4; typedef detail::if_vararg<A3> proto_child5; typedef detail::if_vararg<A3> proto_child6; typedef detail::if_vararg<A3> proto_child7; typedef detail::if_vararg<A3> proto_child8; typedef detail::if_vararg<A3> proto_child9; }; namespace detail { template< template<typename , typename , typename , typename> class T , typename A0 , typename A1 , typename A2 , typename A3 > struct is_callable_<T<A0 , A1 , A2 , A3> BOOST_PROTO_TEMPLATE_ARITY_PARAM(4)> : is_same<A3, callable> {}; } namespace result_of { template<typename Expr> struct child_c<Expr, 4> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child4 value_type; typedef typename detail::expr_traits<typename Expr::proto_child4>::value_type type; }; template<typename Expr> struct child_c<Expr &, 4> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child4 value_type; typedef typename detail::expr_traits<typename Expr::proto_child4>::reference type; BOOST_FORCEINLINE static type call(Expr &e) { return e.proto_base().child4; } }; template<typename Expr> struct child_c<Expr const &, 4> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child4 value_type; typedef typename detail::expr_traits<typename Expr::proto_child4>::const_reference type; BOOST_FORCEINLINE static type call(Expr const &e) { return e.proto_base().child4; } }; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct function < A0 , A1 , A2 , A3 , A4 , void , void , void , void , void > : proto::transform< function< A0 , A1 , A2 , A3 , A4 , void , void , void , void , void > , int > { typedef proto::expr<proto::tag::function, list5<A0 , A1 , A2 , A3 , A4>, 5> type; typedef proto::basic_expr<proto::tag::function, list5<A0 , A1 , A2 , A3 , A4>, 5> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> {}; typedef proto::tag::function proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef detail::if_vararg<A4> proto_child5; typedef detail::if_vararg<A4> proto_child6; typedef detail::if_vararg<A4> proto_child7; typedef detail::if_vararg<A4> proto_child8; typedef detail::if_vararg<A4> proto_child9; }; template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct nary_expr < Tag , A0 , A1 , A2 , A3 , A4 , void , void , void , void , void > : proto::transform< nary_expr< Tag , A0 , A1 , A2 , A3 , A4 , void , void , void , void , void > , int > { typedef proto::expr<Tag, list5<A0 , A1 , A2 , A3 , A4>, 5> type; typedef proto::basic_expr<Tag, list5<A0 , A1 , A2 , A3 , A4>, 5> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> {}; typedef Tag proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef detail::if_vararg<A4> proto_child5; typedef detail::if_vararg<A4> proto_child6; typedef detail::if_vararg<A4> proto_child7; typedef detail::if_vararg<A4> proto_child8; typedef detail::if_vararg<A4> proto_child9; }; namespace detail { template< template<typename , typename , typename , typename , typename> class T , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 > struct is_callable_<T<A0 , A1 , A2 , A3 , A4> BOOST_PROTO_TEMPLATE_ARITY_PARAM(5)> : is_same<A4, callable> {}; } namespace result_of { template<typename Expr> struct child_c<Expr, 5> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child5 value_type; typedef typename detail::expr_traits<typename Expr::proto_child5>::value_type type; }; template<typename Expr> struct child_c<Expr &, 5> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child5 value_type; typedef typename detail::expr_traits<typename Expr::proto_child5>::reference type; BOOST_FORCEINLINE static type call(Expr &e) { return e.proto_base().child5; } }; template<typename Expr> struct child_c<Expr const &, 5> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child5 value_type; typedef typename detail::expr_traits<typename Expr::proto_child5>::const_reference type; BOOST_FORCEINLINE static type call(Expr const &e) { return e.proto_base().child5; } }; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct function < A0 , A1 , A2 , A3 , A4 , A5 , void , void , void , void > : proto::transform< function< A0 , A1 , A2 , A3 , A4 , A5 , void , void , void , void > , int > { typedef proto::expr<proto::tag::function, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> type; typedef proto::basic_expr<proto::tag::function, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> {}; typedef proto::tag::function proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef detail::if_vararg<A5> proto_child6; typedef detail::if_vararg<A5> proto_child7; typedef detail::if_vararg<A5> proto_child8; typedef detail::if_vararg<A5> proto_child9; }; template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct nary_expr < Tag , A0 , A1 , A2 , A3 , A4 , A5 , void , void , void , void > : proto::transform< nary_expr< Tag , A0 , A1 , A2 , A3 , A4 , A5 , void , void , void , void > , int > { typedef proto::expr<Tag, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> type; typedef proto::basic_expr<Tag, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> {}; typedef Tag proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef detail::if_vararg<A5> proto_child6; typedef detail::if_vararg<A5> proto_child7; typedef detail::if_vararg<A5> proto_child8; typedef detail::if_vararg<A5> proto_child9; }; namespace detail { template< template<typename , typename , typename , typename , typename , typename> class T , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 > struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5> BOOST_PROTO_TEMPLATE_ARITY_PARAM(6)> : is_same<A5, callable> {}; } namespace result_of { template<typename Expr> struct child_c<Expr, 6> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child6 value_type; typedef typename detail::expr_traits<typename Expr::proto_child6>::value_type type; }; template<typename Expr> struct child_c<Expr &, 6> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child6 value_type; typedef typename detail::expr_traits<typename Expr::proto_child6>::reference type; BOOST_FORCEINLINE static type call(Expr &e) { return e.proto_base().child6; } }; template<typename Expr> struct child_c<Expr const &, 6> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child6 value_type; typedef typename detail::expr_traits<typename Expr::proto_child6>::const_reference type; BOOST_FORCEINLINE static type call(Expr const &e) { return e.proto_base().child6; } }; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct function < A0 , A1 , A2 , A3 , A4 , A5 , A6 , void , void , void > : proto::transform< function< A0 , A1 , A2 , A3 , A4 , A5 , A6 , void , void , void > , int > { typedef proto::expr<proto::tag::function, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> type; typedef proto::basic_expr<proto::tag::function, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> {}; typedef proto::tag::function proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef detail::if_vararg<A6> proto_child7; typedef detail::if_vararg<A6> proto_child8; typedef detail::if_vararg<A6> proto_child9; }; template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct nary_expr < Tag , A0 , A1 , A2 , A3 , A4 , A5 , A6 , void , void , void > : proto::transform< nary_expr< Tag , A0 , A1 , A2 , A3 , A4 , A5 , A6 , void , void , void > , int > { typedef proto::expr<Tag, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> type; typedef proto::basic_expr<Tag, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> {}; typedef Tag proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef detail::if_vararg<A6> proto_child7; typedef detail::if_vararg<A6> proto_child8; typedef detail::if_vararg<A6> proto_child9; }; namespace detail { template< template<typename , typename , typename , typename , typename , typename , typename> class T , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 > struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6> BOOST_PROTO_TEMPLATE_ARITY_PARAM(7)> : is_same<A6, callable> {}; } namespace result_of { template<typename Expr> struct child_c<Expr, 7> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child7 value_type; typedef typename detail::expr_traits<typename Expr::proto_child7>::value_type type; }; template<typename Expr> struct child_c<Expr &, 7> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child7 value_type; typedef typename detail::expr_traits<typename Expr::proto_child7>::reference type; BOOST_FORCEINLINE static type call(Expr &e) { return e.proto_base().child7; } }; template<typename Expr> struct child_c<Expr const &, 7> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child7 value_type; typedef typename detail::expr_traits<typename Expr::proto_child7>::const_reference type; BOOST_FORCEINLINE static type call(Expr const &e) { return e.proto_base().child7; } }; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct function < A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , void , void > : proto::transform< function< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , void , void > , int > { typedef proto::expr<proto::tag::function, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> type; typedef proto::basic_expr<proto::tag::function, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> {}; typedef proto::tag::function proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef detail::if_vararg<A7> proto_child8; typedef detail::if_vararg<A7> proto_child9; }; template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct nary_expr < Tag , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , void , void > : proto::transform< nary_expr< Tag , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , void , void > , int > { typedef proto::expr<Tag, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> type; typedef proto::basic_expr<Tag, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> {}; typedef Tag proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef detail::if_vararg<A7> proto_child8; typedef detail::if_vararg<A7> proto_child9; }; namespace detail { template< template<typename , typename , typename , typename , typename , typename , typename , typename> class T , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 > struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> BOOST_PROTO_TEMPLATE_ARITY_PARAM(8)> : is_same<A7, callable> {}; } namespace result_of { template<typename Expr> struct child_c<Expr, 8> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child8 value_type; typedef typename detail::expr_traits<typename Expr::proto_child8>::value_type type; }; template<typename Expr> struct child_c<Expr &, 8> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child8 value_type; typedef typename detail::expr_traits<typename Expr::proto_child8>::reference type; BOOST_FORCEINLINE static type call(Expr &e) { return e.proto_base().child8; } }; template<typename Expr> struct child_c<Expr const &, 8> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child8 value_type; typedef typename detail::expr_traits<typename Expr::proto_child8>::const_reference type; BOOST_FORCEINLINE static type call(Expr const &e) { return e.proto_base().child8; } }; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct function < A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , void > : proto::transform< function< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , void > , int > { typedef proto::expr<proto::tag::function, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> type; typedef proto::basic_expr<proto::tag::function, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> {}; typedef proto::tag::function proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8; typedef detail::if_vararg<A8> proto_child9; }; template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct nary_expr < Tag , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , void > : proto::transform< nary_expr< Tag , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , void > , int > { typedef proto::expr<Tag, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> type; typedef proto::basic_expr<Tag, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> {}; typedef Tag proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8; typedef detail::if_vararg<A8> proto_child9; }; namespace detail { template< template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class T , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 > struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> BOOST_PROTO_TEMPLATE_ARITY_PARAM(9)> : is_same<A8, callable> {}; } namespace result_of { template<typename Expr> struct child_c<Expr, 9> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child9 value_type; typedef typename detail::expr_traits<typename Expr::proto_child9>::value_type type; }; template<typename Expr> struct child_c<Expr &, 9> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child9 value_type; typedef typename detail::expr_traits<typename Expr::proto_child9>::reference type; BOOST_FORCEINLINE static type call(Expr &e) { return e.proto_base().child9; } }; template<typename Expr> struct child_c<Expr const &, 9> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child9 value_type; typedef typename detail::expr_traits<typename Expr::proto_child9>::const_reference type; BOOST_FORCEINLINE static type call(Expr const &e) { return e.proto_base().child9; } }; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct function : proto::transform< function< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 > , int > { typedef proto::expr<proto::tag::function, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> type; typedef proto::basic_expr<proto::tag::function, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> {}; typedef proto::tag::function proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8; typedef A9 proto_child9; }; template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct nary_expr : proto::transform< nary_expr< Tag , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 > , int > { typedef proto::expr<Tag, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> type; typedef proto::basic_expr<Tag, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> {}; typedef Tag proto_tag; typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8; typedef A9 proto_child9; }; namespace detail { template< template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class T , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 > struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> BOOST_PROTO_TEMPLATE_ARITY_PARAM(10)> : is_same<A9, callable> {}; } namespace result_of { template<typename Expr> struct child_c<Expr, 10> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child10 value_type; typedef typename detail::expr_traits<typename Expr::proto_child10>::value_type type; }; template<typename Expr> struct child_c<Expr &, 10> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child10 value_type; typedef typename detail::expr_traits<typename Expr::proto_child10>::reference type; BOOST_FORCEINLINE static type call(Expr &e) { return e.proto_base().child10; } }; template<typename Expr> struct child_c<Expr const &, 10> { BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); typedef typename Expr::proto_child10 value_type; typedef typename detail::expr_traits<typename Expr::proto_child10>::const_reference type; BOOST_FORCEINLINE static type call(Expr const &e) { return e.proto_base().child10; } }; } PK �J�[ �fH6U 6U " detail/preprocessed/make_expr_.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file make_expr_.hpp /// Contains definition of make_expr_\<\> class template. // // Copyright 2008 Eric Niebler. 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) template< typename Tag , typename Domain , typename A0 = void , typename A1 = void , typename A2 = void , typename A3 = void , typename A4 = void , typename A5 = void , typename A6 = void , typename A7 = void , typename A8 = void , typename A9 = void , typename _ = void > struct make_expr_ {}; template<typename Domain, typename A> struct make_expr_<tag::terminal, Domain, A , void , void , void , void , void , void , void , void , void , void> { typedef typename proto::detail::protoify<A, Domain>::result_type result_type; BOOST_FORCEINLINE result_type operator()(typename add_reference<A>::type a) const { return proto::detail::protoify<A, Domain>()(a); } }; template<typename A> struct make_expr_<tag::terminal, deduce_domain, A , void , void , void , void , void , void , void , void , void , void> : make_expr_<tag::terminal, default_domain, A> {}; template<typename Tag, typename Domain , typename A0> struct make_expr_<Tag, Domain , A0 , void , void , void , void , void , void , void , void , void, void> { typedef list1< typename boost::proto::detail::protoify< A0 , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(typename add_reference<A0 >::type a0) const { expr_type const that = { boost::proto::detail::protoify< A0 , Domain >()(a0) }; return proto_generator()(that); } }; template<typename Tag , typename A0> struct make_expr_<Tag, deduce_domain , A0 , void , void , void , void , void , void , void , void , void, void> : make_expr_< Tag , typename deduce_domain1<A0>::type , A0 > {}; template<typename Tag, typename Domain , typename A0 , typename A1> struct make_expr_<Tag, Domain , A0 , A1 , void , void , void , void , void , void , void , void, void> { typedef list2< typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1) const { expr_type const that = { boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) }; return proto_generator()(that); } }; template<typename Tag , typename A0 , typename A1> struct make_expr_<Tag, deduce_domain , A0 , A1 , void , void , void , void , void , void , void , void, void> : make_expr_< Tag , typename deduce_domain2<A0 , A1>::type , A0 , A1 > {}; template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2> struct make_expr_<Tag, Domain , A0 , A1 , A2 , void , void , void , void , void , void , void, void> { typedef list3< typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2) const { expr_type const that = { boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) }; return proto_generator()(that); } }; template<typename Tag , typename A0 , typename A1 , typename A2> struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , void , void , void , void , void , void , void, void> : make_expr_< Tag , typename deduce_domain3<A0 , A1 , A2>::type , A0 , A1 , A2 > {}; template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3> struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , void , void , void , void , void , void, void> { typedef list4< typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3) const { expr_type const that = { boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) }; return proto_generator()(that); } }; template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3> struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , void , void , void , void , void , void, void> : make_expr_< Tag , typename deduce_domain4<A0 , A1 , A2 , A3>::type , A0 , A1 , A2 , A3 > {}; template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , void , void , void , void , void, void> { typedef list5< typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4) const { expr_type const that = { boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) }; return proto_generator()(that); } }; template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , void , void , void , void , void, void> : make_expr_< Tag , typename deduce_domain5<A0 , A1 , A2 , A3 , A4>::type , A0 , A1 , A2 , A3 , A4 > {}; template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , void , void , void , void, void> { typedef list6< typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5) const { expr_type const that = { boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) }; return proto_generator()(that); } }; template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , void , void , void , void, void> : make_expr_< Tag , typename deduce_domain6<A0 , A1 , A2 , A3 , A4 , A5>::type , A0 , A1 , A2 , A3 , A4 , A5 > {}; template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , void , void , void, void> { typedef list7< typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6) const { expr_type const that = { boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) }; return proto_generator()(that); } }; template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , void , void , void, void> : make_expr_< Tag , typename deduce_domain7<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type , A0 , A1 , A2 , A3 , A4 , A5 , A6 > {}; template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , void , void, void> { typedef list8< typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7) const { expr_type const that = { boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) }; return proto_generator()(that); } }; template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , void , void, void> : make_expr_< Tag , typename deduce_domain8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 > {}; template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , void, void> { typedef list9< typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type , typename boost::proto::detail::protoify< A8 , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7 , typename add_reference<A8 >::type a8) const { expr_type const that = { boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) , boost::proto::detail::protoify< A8 , Domain >()(a8) }; return proto_generator()(that); } }; template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , void, void> : make_expr_< Tag , typename deduce_domain9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 > {}; template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , void> { typedef list10< typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type , typename boost::proto::detail::protoify< A8 , Domain >::result_type , typename boost::proto::detail::protoify< A9 , Domain >::result_type > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7 , typename add_reference<A8 >::type a8 , typename add_reference<A9 >::type a9) const { expr_type const that = { boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) , boost::proto::detail::protoify< A8 , Domain >()(a8) , boost::proto::detail::protoify< A9 , Domain >()(a9) }; return proto_generator()(that); } }; template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , void> : make_expr_< Tag , typename deduce_domain10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>::type , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 > {}; PK �J�[���� K K ) detail/preprocessed/generate_by_value.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file generate_by_value.hpp /// Contains definition of by_value_generator_\<\> class template. // // Copyright 2008 Eric Niebler. 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) template<typename Tag , typename Arg0 > struct by_value_generator_< proto::expr<Tag, list1<Arg0>, 1> > { typedef list1<Arg0> src_args; typedef list1< typename uncvref<Arg0 >::type > dst_args; typedef proto::expr<Tag, src_args, 1> src_type; typedef proto::expr<Tag, dst_args, 1> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 }; return that; } }; template<typename Tag , typename Arg0 > struct by_value_generator_< proto::basic_expr<Tag, list1<Arg0>, 1> > { typedef list1<Arg0> src_args; typedef list1< typename uncvref<Arg0 >::type > dst_args; typedef proto::basic_expr<Tag, src_args, 1> src_type; typedef proto::basic_expr<Tag, dst_args, 1> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 > struct by_value_generator_< proto::expr<Tag, list2<Arg0 , Arg1>, 2> > { typedef list2<Arg0 , Arg1> src_args; typedef list2< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type > dst_args; typedef proto::expr<Tag, src_args, 2> src_type; typedef proto::expr<Tag, dst_args, 2> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 > struct by_value_generator_< proto::basic_expr<Tag, list2<Arg0 , Arg1>, 2> > { typedef list2<Arg0 , Arg1> src_args; typedef list2< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type > dst_args; typedef proto::basic_expr<Tag, src_args, 2> src_type; typedef proto::basic_expr<Tag, dst_args, 2> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 > struct by_value_generator_< proto::expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3> > { typedef list3<Arg0 , Arg1 , Arg2> src_args; typedef list3< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type > dst_args; typedef proto::expr<Tag, src_args, 3> src_type; typedef proto::expr<Tag, dst_args, 3> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 > struct by_value_generator_< proto::basic_expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3> > { typedef list3<Arg0 , Arg1 , Arg2> src_args; typedef list3< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type > dst_args; typedef proto::basic_expr<Tag, src_args, 3> src_type; typedef proto::basic_expr<Tag, dst_args, 3> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 > struct by_value_generator_< proto::expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4> > { typedef list4<Arg0 , Arg1 , Arg2 , Arg3> src_args; typedef list4< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type > dst_args; typedef proto::expr<Tag, src_args, 4> src_type; typedef proto::expr<Tag, dst_args, 4> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 , e.child3 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 > struct by_value_generator_< proto::basic_expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4> > { typedef list4<Arg0 , Arg1 , Arg2 , Arg3> src_args; typedef list4< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type > dst_args; typedef proto::basic_expr<Tag, src_args, 4> src_type; typedef proto::basic_expr<Tag, dst_args, 4> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 , e.child3 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 > struct by_value_generator_< proto::expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5> > { typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> src_args; typedef list5< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type > dst_args; typedef proto::expr<Tag, src_args, 5> src_type; typedef proto::expr<Tag, dst_args, 5> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 , e.child3 , e.child4 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 > struct by_value_generator_< proto::basic_expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5> > { typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> src_args; typedef list5< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type > dst_args; typedef proto::basic_expr<Tag, src_args, 5> src_type; typedef proto::basic_expr<Tag, dst_args, 5> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 , e.child3 , e.child4 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 > struct by_value_generator_< proto::expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6> > { typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> src_args; typedef list6< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type > dst_args; typedef proto::expr<Tag, src_args, 6> src_type; typedef proto::expr<Tag, dst_args, 6> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 > struct by_value_generator_< proto::basic_expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6> > { typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> src_args; typedef list6< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type > dst_args; typedef proto::basic_expr<Tag, src_args, 6> src_type; typedef proto::basic_expr<Tag, dst_args, 6> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 > struct by_value_generator_< proto::expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7> > { typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> src_args; typedef list7< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type > dst_args; typedef proto::expr<Tag, src_args, 7> src_type; typedef proto::expr<Tag, dst_args, 7> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 > struct by_value_generator_< proto::basic_expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7> > { typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> src_args; typedef list7< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type > dst_args; typedef proto::basic_expr<Tag, src_args, 7> src_type; typedef proto::basic_expr<Tag, dst_args, 7> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 > struct by_value_generator_< proto::expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8> > { typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> src_args; typedef list8< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type > dst_args; typedef proto::expr<Tag, src_args, 8> src_type; typedef proto::expr<Tag, dst_args, 8> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 > struct by_value_generator_< proto::basic_expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8> > { typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> src_args; typedef list8< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type > dst_args; typedef proto::basic_expr<Tag, src_args, 8> src_type; typedef proto::basic_expr<Tag, dst_args, 8> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 > struct by_value_generator_< proto::expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9> > { typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> src_args; typedef list9< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type > dst_args; typedef proto::expr<Tag, src_args, 9> src_type; typedef proto::expr<Tag, dst_args, 9> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 > struct by_value_generator_< proto::basic_expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9> > { typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> src_args; typedef list9< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type > dst_args; typedef proto::basic_expr<Tag, src_args, 9> src_type; typedef proto::basic_expr<Tag, dst_args, 9> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 > struct by_value_generator_< proto::expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10> > { typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> src_args; typedef list10< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type , typename uncvref<Arg9 >::type > dst_args; typedef proto::expr<Tag, src_args, 10> src_type; typedef proto::expr<Tag, dst_args, 10> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 , e.child9 }; return that; } }; template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 > struct by_value_generator_< proto::basic_expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10> > { typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> src_args; typedef list10< typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type , typename uncvref<Arg9 >::type > dst_args; typedef proto::basic_expr<Tag, src_args, 10> src_type; typedef proto::basic_expr<Tag, dst_args, 10> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 , e.child9 }; return that; } }; PK �J�[fPa�� � detail/or_n.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/or_n.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/or_n.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file or_n.hpp /// Definitions of or_N // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (2, BOOST_PROTO_MAX_LOGICAL_ARITY, <boost/proto/detail/or_n.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else // BOOST_PP_IS_ITERATING #define N BOOST_PP_ITERATION() template<bool B, typename Expr, typename BasicExpr, BOOST_PP_ENUM_PARAMS(N, typename G)> struct BOOST_PP_CAT(or_, N) #if 2 == N : mpl::bool_<matches_<Expr, BasicExpr, typename G1::proto_grammar>::value> { typedef G1 which; }; #else : BOOST_PP_CAT(or_, BOOST_PP_DEC(N))< matches_<Expr, BasicExpr, typename G1::proto_grammar>::value , Expr, BasicExpr, BOOST_PP_ENUM_SHIFTED_PARAMS(N, G) > {}; #endif template<typename Expr, typename BasicExpr BOOST_PP_ENUM_TRAILING_PARAMS(N, typename G)> struct BOOST_PP_CAT(or_, N)<true, Expr, BasicExpr, BOOST_PP_ENUM_PARAMS(N, G)> : mpl::true_ { typedef G0 which; }; #undef N #endif PK �J�[�~�n n detail/basic_expr.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/basic_expr.hpp> #elif !defined(BOOST_PP_IS_ITERATING) /// INTERNAL ONLY /// #define BOOST_PROTO_CHILD(Z, N, DATA) \ typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(proto_child, N); \ BOOST_PP_CAT(proto_child, N) BOOST_PP_CAT(child, N); \ /**< INTERNAL ONLY */ /// INTERNAL ONLY /// #define BOOST_PROTO_VOID(Z, N, DATA) \ typedef void BOOST_PP_CAT(proto_child, N); \ /**< INTERNAL ONLY */ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/basic_expr.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file basic_expr.hpp /// Contains definition of basic_expr\<\> class template. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif // The expr<> specializations are actually defined here. #define BOOST_PROTO_DEFINE_TERMINAL #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 0, <boost/proto/detail/basic_expr.hpp>)) #include BOOST_PP_ITERATE() #undef BOOST_PROTO_DEFINE_TERMINAL #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/basic_expr.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_CHILD #undef BOOST_PROTO_VOID #else #define ARG_COUNT BOOST_PP_MAX(1, BOOST_PP_ITERATION()) /// \brief Simplified representation of a node in an expression tree. /// /// \c proto::basic_expr\<\> is a node in an expression template tree. It /// is a container for its child sub-trees. It also serves as /// the terminal nodes of the tree. /// /// \c Tag is type that represents the operation encoded by /// this expression. It is typically one of the structs /// in the \c boost::proto::tag namespace, but it doesn't /// have to be. /// /// \c Args is a type list representing the type of the children /// of this expression. It is an instantiation of one /// of \c proto::list1\<\>, \c proto::list2\<\>, etc. The /// child types must all themselves be either \c expr\<\> /// or <tt>proto::expr\<\>&</tt>. If \c Args is an /// instantiation of \c proto::term\<\> then this /// \c expr\<\> type represents a terminal expression; /// the parameter to the \c proto::term\<\> template /// represents the terminal's value type. /// /// \c Arity is an integral constant representing the number of child /// nodes this node contains. If \c Arity is 0, then this /// node is a terminal. /// /// \c proto::basic_expr\<\> is a valid Fusion random-access sequence, where /// the elements of the sequence are the child expressions. #ifdef BOOST_PROTO_DEFINE_TERMINAL template<typename Tag, typename Arg0> struct basic_expr<Tag, term<Arg0>, 0> #else template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(ARG_COUNT, typename Arg)> struct basic_expr<Tag, BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)>, BOOST_PP_ITERATION() > #endif { typedef Tag proto_tag; static const long proto_arity_c = BOOST_PP_ITERATION(); typedef mpl::long_<BOOST_PP_ITERATION() > proto_arity; typedef basic_expr proto_base_expr; #ifdef BOOST_PROTO_DEFINE_TERMINAL typedef term<Arg0> proto_args; #else typedef BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)> proto_args; #endif typedef basic_expr proto_grammar; typedef basic_default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef basic_expr proto_derived_expr; typedef void proto_is_expr_; /**< INTERNAL ONLY */ BOOST_PP_REPEAT(ARG_COUNT, BOOST_PROTO_CHILD, ~) BOOST_PP_REPEAT_FROM_TO(ARG_COUNT, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_VOID, ~) /// \return *this /// BOOST_FORCEINLINE basic_expr const &proto_base() const { return *this; } /// \overload /// BOOST_FORCEINLINE basic_expr &proto_base() { return *this; } #ifdef BOOST_PROTO_DEFINE_TERMINAL /// \return A new \c expr\<\> object initialized with the specified /// arguments. /// template<typename A0> BOOST_FORCEINLINE static basic_expr const make(A0 &a0) { return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0)); } /// \overload /// template<typename A0> BOOST_FORCEINLINE static basic_expr const make(A0 const &a0) { return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0)); } #else /// \return A new \c expr\<\> object initialized with the specified /// arguments. /// template<BOOST_PP_ENUM_PARAMS(ARG_COUNT, typename A)> BOOST_FORCEINLINE static basic_expr const make(BOOST_PP_ENUM_BINARY_PARAMS(ARG_COUNT, A, const &a)) { basic_expr that = {BOOST_PP_ENUM_PARAMS(ARG_COUNT, a)}; return that; } #endif #if 1 == BOOST_PP_ITERATION() /// If \c Tag is \c boost::proto::tag::address_of and \c proto_child0 is /// <tt>T&</tt>, then \c address_of_hack_type_ is <tt>T*</tt>. /// Otherwise, it is some undefined type. typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_; /// \return The address of <tt>this->child0</tt> if \c Tag is /// \c boost::proto::tag::address_of. Otherwise, this function will /// fail to compile. /// /// \attention Proto overloads <tt>operator&</tt>, which means that /// proto-ified objects cannot have their addresses taken, unless we use /// the following hack to make \c &x implicitly convertible to \c X*. BOOST_FORCEINLINE operator address_of_hack_type_() const { return boost::addressof(this->child0); } #else /// INTERNAL ONLY /// typedef detail::not_a_valid_type address_of_hack_type_; #endif }; #undef ARG_COUNT #endif PK �J�[Ͽ� � detail/ignore_unused.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file ignore_unused.hpp /// Definintion of ignore_unused, a dummy function for suppressing compiler /// warnings // // Copyright 2008 Eric Niebler. 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_PROTO_DETAIL_IGNORE_UNUSED_HPP_EAN_03_03_2008 #define BOOST_PROTO_DETAIL_IGNORE_UNUSED_HPP_EAN_03_03_2008 #include <boost/config.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { template<typename T> BOOST_FORCEINLINE void ignore_unused(T const &) {} } }} #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[%���B B detail/extends_funop_const.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES BOOST_PROTO_EXTENDS_FUNCTION_() BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) #else #include <boost/proto/detail/preprocessed/extends_funop_const.hpp> #endif #else #define BOOST_PP_LOCAL_MACRO(N) \ BOOST_PROTO_DEFINE_FUN_OP_CONST(1, N, ~) \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/extends_funop_const.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file extends_funop_const.hpp /// Definitions for extends\<\>::operator() // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif BOOST_PROTO_EXTENDS_FUNCTION_() #define BOOST_PP_LOCAL_LIMITS \ (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY)) #include BOOST_PP_LOCAL_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #endif PK �J�[I��� � detail/poly_function_funop.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/poly_function_funop.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_NORMALIZE_ARG(Z, N, DATA) \ static_cast<typename normalize_arg<BOOST_PP_CAT(A, N) const &> \ ::reference>(BOOST_PP_CAT(a, N)) \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/poly_function_funop.hpp") #endif /////////////////////////////////////////////////////////////////////////////// // poly_function_funop.hpp // Contains overloads of poly_function\<\>::operator() // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/poly_function_funop.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_NORMALIZE_ARG #else #define N BOOST_PP_ITERATION() template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct result<This(BOOST_PP_ENUM_PARAMS(N, A))> : Derived::template impl< BOOST_PP_ENUM_BINARY_PARAMS( N , typename normalize_arg<A , >::type BOOST_PP_INTERCEPT ) > { typedef typename result::result_type type; }; template<BOOST_PP_ENUM_PARAMS(N, typename A)> typename result< Derived const( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const & BOOST_PP_INTERCEPT) ) >::type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const { result< Derived const( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const & BOOST_PP_INTERCEPT) ) > impl; return impl(BOOST_PP_ENUM(N, BOOST_PROTO_NORMALIZE_ARG, ~)); } #undef N #endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES PK �J�[=�8QA A detail/template_arity_helper.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/template_arity_helper.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/template_arity_helper.hpp") #endif /////////////////////////////////////////////////////////////////////////////// // template_arity_helper.hpp // Overloads of template_arity_helper, used by the template_arity\<\> class template // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/template_arity_helper.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else #define N BOOST_PP_ITERATION() template< template<BOOST_PP_ENUM_PARAMS(N, typename P)> class F , BOOST_PP_ENUM_PARAMS(N, typename T) > sized_type<BOOST_PP_INC(N)>::type template_arity_helper(F<BOOST_PP_ENUM_PARAMS(N, T)> **, mpl::int_<N> *); #undef N #endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES PK �J�[9&�� detail/args.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/args.hpp> #elif !defined(BOOST_PP_IS_ITERATING) /// INTERNAL ONLY /// #define BOOST_PROTO_DEFINE_CHILD_N(Z, N, DATA) \ typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(child, N); \ /**< INTERNAL ONLY */ /// INTERNAL ONLY /// #define BOOST_PROTO_DEFINE_VOID_N(z, n, data) \ typedef mpl::void_ BOOST_PP_CAT(child, n); \ /**< INTERNAL ONLY */ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/args.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file args.hpp /// Contains definition of \c term\<\>, \c list1\<\>, \c list2\<\>, ... /// class templates. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif /// \brief A type sequence, for use as the 2nd parameter to the \c expr\<\> class template. /// /// A type sequence, for use as the 2nd parameter to the \c expr\<\> class template. /// The types in the sequence correspond to the children of a node in an expression tree. template< typename Arg0 > struct term { static const long arity = 0; typedef Arg0 child0; BOOST_PP_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_DEFINE_VOID_N, ~) /// INTERNAL ONLY /// typedef Arg0 back_; }; #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/args.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_DEFINE_VOID_N #undef BOOST_PROTO_DEFINE_CHILD_N #else #define N BOOST_PP_ITERATION() /// \brief A type sequence, for use as the 2nd parameter to the \c expr\<\> class template. /// /// A type sequence, for use as the 2nd parameter to the \c expr\<\> class template. /// The types in the sequence correspond to the children of a node in an expression tree. template< BOOST_PP_ENUM_PARAMS(N, typename Arg) > struct BOOST_PP_CAT(list, N) { static const long arity = N; BOOST_PP_REPEAT(N, BOOST_PROTO_DEFINE_CHILD_N, ~) BOOST_PP_REPEAT_FROM_TO(N, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_DEFINE_VOID_N, ~) /// INTERNAL ONLY /// typedef BOOST_PP_CAT(Arg, BOOST_PP_DEC(N)) back_; }; #undef N #endif PK �J�[�X�# # detail/memfun_funop.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/memfun_funop.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/memfun_funop.hpp") #endif /////////////////////////////////////////////////////////////////////////////// // memfun_funop.hpp // Contains overloads of memfun::operator(). // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/memfun_funop.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else #define N BOOST_PP_ITERATION() template<BOOST_PP_ENUM_PARAMS(N, typename A)> BOOST_FORCEINLINE result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const { BOOST_PROTO_USE_GET_POINTER(); return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(BOOST_PP_ENUM_PARAMS(N, a)); } #undef N #endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES PK �J�[��B� detail/funop.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/funop.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_AS_CHILD_TYPE(Z, N, DATA) \ typename proto::result_of::as_child<BOOST_PP_CAT(A, N), Domain>::type \ /**/ #define BOOST_PROTO_AS_CHILD(Z, N, DATA) \ proto::as_child<Domain>(BOOST_PP_CAT(a, N)) \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/funop.hpp") #endif /////////////////////////////////////////////////////////////////////////////// // funop.hpp // Contains definition of funop[n]\<\> class template. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY), <boost/proto/detail/funop.hpp>)) #include BOOST_PP_ITERATE() #undef BOOST_PROTO_AS_CHILD #undef BOOST_PROTO_AS_CHILD_TYPE #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else /// \brief A helper metafunction for computing the /// return type of \c proto::expr\<\>::operator(). template<typename Expr, typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename A)> struct BOOST_PP_CAT(funop, BOOST_PP_ITERATION()) { typedef typename proto::base_expr< Domain , tag::function , BOOST_PP_CAT(list, BOOST_PP_INC(BOOST_PP_ITERATION()))< Expr & BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), BOOST_PROTO_AS_CHILD_TYPE, ~) > >::type type; BOOST_FORCEINLINE static type const call( Expr &e BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, &a) ) { type that = { e BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), BOOST_PROTO_AS_CHILD, ~) }; return that; } }; /// \brief A helper metafunction for computing the /// return type of \c proto::expr\<\>::operator(). template<typename Expr BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename A), typename This, typename Domain> struct funop<Expr(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), This, Domain> : BOOST_PP_CAT(funop, BOOST_PP_ITERATION())< typename detail::same_cv<Expr, This>::type , Domain BOOST_PP_ENUM_TRAILING_BINARY_PARAMS( BOOST_PP_ITERATION() , typename remove_reference<A , >::type BOOST_PP_INTERCEPT ) > {}; #endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES PK �J�[ _�� � detail/unpack_expr_.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/unpack_expr_.hpp> #elif !defined(BOOST_PP_IS_ITERATING) /// INTERNAL ONLY /// #define BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE(Z, N, DATA) \ typedef typename fusion::result_of::next< \ BOOST_PP_CAT(fusion_iterator, N)>::type \ BOOST_PP_CAT(fusion_iterator, BOOST_PP_INC(N)); \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_FUSION_ITERATORS_TYPE(N) \ typedef \ typename fusion::result_of::begin<Sequence const>::type \ fusion_iterator0; \ BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE, fusion_iterator) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \ typename add_const< \ typename fusion::result_of::value_of< \ BOOST_PP_CAT(fusion_iterator, N) \ >::type \ >::type \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_FUSION_NEXT_ITERATOR(Z, N, DATA) \ BOOST_PP_CAT(fusion_iterator, BOOST_PP_INC(N)) BOOST_PP_CAT(it, BOOST_PP_INC(N)) = \ fusion::next(BOOST_PP_CAT(it, N)); \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_FUSION_ITERATORS(N) \ fusion_iterator0 it0 = fusion::begin(sequence); \ BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_PROTO_FUSION_NEXT_ITERATOR, fusion_iterator) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_FUSION_AT(Z, N, DATA) \ *BOOST_PP_CAT(it, N) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE(Z, N, DATA) \ typename detail::protoify< \ BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \ , Domain \ >::result_type \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_FUSION_AS_CHILD_AT(Z, N, DATA) \ detail::protoify< \ BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \ , Domain \ >()(BOOST_PROTO_FUSION_AT(Z, N, DATA)) \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/unpack_expr_.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file make_expr_.hpp /// Contains definition of make_expr_\<\> class template. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif template<typename Tag, typename Domain, typename Sequence, std::size_t Size> struct unpack_expr_ {}; template<typename Domain, typename Sequence> struct unpack_expr_<tag::terminal, Domain, Sequence, 1u> { typedef typename add_const< typename fusion::result_of::value_of< typename fusion::result_of::begin<Sequence>::type >::type >::type terminal_type; typedef typename proto::detail::protoify< terminal_type , Domain >::result_type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { return proto::detail::protoify<terminal_type, Domain>()(fusion::at_c<0>(sequence)); } }; template<typename Sequence> struct unpack_expr_<tag::terminal, deduce_domain, Sequence, 1u> : unpack_expr_<tag::terminal, default_domain, Sequence, 1u> {}; #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/unpack_expr_.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_FUSION_AT #undef BOOST_PROTO_FUSION_AT_TYPE #undef BOOST_PROTO_FUSION_AS_CHILD_AT #undef BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE #undef BOOST_PROTO_FUSION_NEXT_ITERATOR #undef BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE #undef BOOST_PROTO_FUSION_ITERATORS #undef BOOST_PROTO_FUSION_ITERATORS_TYPE #else // BOOST_PP_IS_ITERATING #define N BOOST_PP_ITERATION() #define M BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N) template<typename Tag, typename Domain, typename Sequence> struct unpack_expr_<Tag, Domain, Sequence, N> { BOOST_PROTO_FUSION_ITERATORS_TYPE(N) typedef BOOST_PP_CAT(list, N)< BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE, ~) > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { BOOST_PROTO_FUSION_ITERATORS(N) expr_type const that = { BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AS_CHILD_AT, ~) }; return proto_generator()(that); } }; template<typename Tag, typename Sequence> struct unpack_expr_<Tag, deduce_domain, Sequence, N> { BOOST_PROTO_FUSION_ITERATORS_TYPE(N) typedef unpack_expr_< Tag , typename BOOST_PP_CAT(deduce_domain, N)< BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AT_TYPE, ~) >::type , Sequence , N > other; typedef typename other::type type; BOOST_FORCEINLINE static type const call(Sequence const &sequence) { return other::call(sequence); } }; #undef N #undef M #endif PK �J�[7�Z D D detail/expr_funop.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// // expr1.hpp // Contains definition of expr\<\>::operator() overloads. // // Copyright 2008 Eric Niebler. 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) #define N BOOST_PP_ITERATION() /// \overload /// template<BOOST_PP_ENUM_PARAMS(N, typename A)> BOOST_FORCEINLINE typename result_of::BOOST_PP_CAT(funop, N)< expr const , default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) >::type const operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const { return result_of::BOOST_PP_CAT(funop, N)< expr const , default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) >::call(*this BOOST_PP_ENUM_TRAILING_PARAMS(N, a)); } #ifdef BOOST_PROTO_DEFINE_TERMINAL /// \overload /// template<BOOST_PP_ENUM_PARAMS(N, typename A)> BOOST_FORCEINLINE typename result_of::BOOST_PP_CAT(funop, N)< expr , default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) >::type const operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) { return result_of::BOOST_PP_CAT(funop, N)< expr , default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) >::call(*this BOOST_PP_ENUM_TRAILING_PARAMS(N, a)); } #endif #undef N PK �J�[�b��� � detail/deduce_domain.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file deduce_domain.hpp /// Contains definition of deduce_domain\<\> class templates /// for finding the domain that is common among the specified /// domains // // Copyright 2010 Daniel Wallin, Eric Niebler. 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) // // Many thanks to Daniel Wallin who first implemented this code. Thanks // also to Jeremiah Willcock, John Bytheway and Krishna Achuthan who // offered alternate solutions to this tricky programming problem. #ifndef BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010 #define BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010 #include <boost/config.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/iteration/local.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/preprocessor/arithmetic/inc.hpp> #include <boost/mpl/assert.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/proto/proto_fwd.hpp> #ifndef BOOST_PROTO_ASSERT_VALID_DOMAIN # define BOOST_PROTO_ASSERT_VALID_DOMAIN(DOM) BOOST_MPL_ASSERT_NOT((boost::is_same<DOM, boost::proto::detail::not_a_domain>)) #endif namespace boost { namespace proto { namespace detail { template<typename Domain> struct domain_ : domain_<typename Domain::proto_super_domain> { typedef Domain type; typedef domain_<typename Domain::proto_super_domain> base; #ifdef BOOST_NO_CXX11_DECLTYPE using base::deduce98; static int const index = base::index + 1; static typename sized_type<index>::type deduce98(domain_<Domain>*); #else using base::deduce0x; static Domain deduce0x(domain_<Domain>*); #endif }; template<> struct domain_<not_a_domain> { typedef not_a_domain type; #ifdef BOOST_NO_CXX11_DECLTYPE static int const index = 1; static sized_type<1>::type deduce98(void*); #else static not_a_domain deduce0x(void*); #endif }; template<> struct domain_<default_domain> : domain_<not_a_domain> {}; template<> struct domain_<basic_default_domain> : domain_<not_a_domain> {}; sized_type<1>::type default_test(void*, void*); sized_type<2>::type default_test(domain_<default_domain>*, void*); sized_type<2>::type default_test(domain_<basic_default_domain>*, void*); sized_type<3>::type default_test(void*, domain_<default_domain>*); sized_type<3>::type default_test(void*, domain_<basic_default_domain>*); sized_type<4>::type default_test(domain_<default_domain>*, domain_<default_domain>*); sized_type<4>::type default_test(domain_<basic_default_domain>*, domain_<default_domain>*); sized_type<4>::type default_test(domain_<default_domain>*, domain_<basic_default_domain>*); sized_type<4>::type default_test(domain_<basic_default_domain>*, domain_<basic_default_domain>*); #ifdef BOOST_NO_CXX11_DECLTYPE template<int N, typename Domain> struct nth_domain : nth_domain<N - 1, typename Domain::base> {}; template<typename Domain> struct nth_domain<0, Domain> : Domain {}; #endif template<typename D0> struct common_domain1 { typedef D0 type; }; template<typename E0> struct deduce_domain1 : domain_of<E0> {}; template< typename D0 , typename D1 , int DefaultCase = sizeof(proto::detail::default_test((domain_<D0>*)0, (domain_<D1>*)0)) > struct common_domain2 { #ifdef BOOST_NO_CXX11_DECLTYPE static int const index = domain_<D0>::index - sizeof(domain_<D0>::deduce98((domain_<D1>*)0)); typedef typename nth_domain<index, domain_<D0> >::type type; #else typedef decltype(domain_<D0>::deduce0x((domain_<D1>*)0)) type; #endif }; template<typename D0, typename D1> struct common_domain2<D0, D1, 2> { typedef D1 type; }; template<typename D0, typename D1> struct common_domain2<D0, D1, 3> { typedef D0 type; }; template<typename D0> struct common_domain2<D0, default_domain, 4> { typedef D0 type; }; template<typename D0> struct common_domain2<D0, basic_default_domain, 4> { typedef D0 type; }; template<typename D1> struct common_domain2<default_domain, D1, 4> { typedef D1 type; }; template<typename D1> struct common_domain2<basic_default_domain, D1, 4> { typedef D1 type; }; template<> struct common_domain2<default_domain, default_domain, 4> { typedef default_domain type; }; template<> struct common_domain2<basic_default_domain, default_domain, 4> { typedef default_domain type; }; template<> struct common_domain2<default_domain, basic_default_domain, 4> { typedef default_domain type; }; template<> struct common_domain2<basic_default_domain, basic_default_domain, 4> { typedef basic_default_domain type; }; template<typename E0, typename E1> struct deduce_domain2 : common_domain2< typename domain_of<E0>::type , typename domain_of<E1>::type > {}; #include <boost/proto/detail/deduce_domain_n.hpp> } } } #endif // BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010 PK �J�[0�o*� � detail/deep_copy.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/deep_copy.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_DEFINE_DEEP_COPY_TYPE(Z, N, DATA) \ typename deep_copy_impl< \ typename remove_reference< \ typename Expr::BOOST_PP_CAT(proto_child, N) \ >::type::proto_derived_expr \ >::result_type \ /**/ #define BOOST_PROTO_DEFINE_DEEP_COPY_FUN(Z, N, DATA) \ proto::deep_copy(e.proto_base().BOOST_PP_CAT(child, N)) \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/deep_copy.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file deep_copy.hpp /// Replace all nodes stored by reference by nodes stored by value. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/deep_copy.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_DEFINE_DEEP_COPY_FUN #undef BOOST_PROTO_DEFINE_DEEP_COPY_TYPE #else #define N BOOST_PP_ITERATION() template<typename Expr> struct deep_copy_impl<Expr, N> { typedef typename base_expr< typename Expr::proto_domain , typename Expr::proto_tag , BOOST_PP_CAT(list, N)< BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_DEEP_COPY_TYPE, ~) > >::type expr_type; typedef typename Expr::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; template<typename Expr2, typename S, typename D> result_type operator()(Expr2 const &e, S const &, D const &) const { expr_type const that = { BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_DEEP_COPY_FUN, ~) }; return proto_generator()(that); } }; #undef N #endif PK �J�[��f�� � detail/static_const.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file static_const.hpp /// Contains definition of static_const for declaring static constants that // // Copyright 2008 Eric Niebler. 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_PROTO_DETAIL_STATIC_CONST_HPP_EAN_20_07_2012 #define BOOST_PROTO_DETAIL_STATIC_CONST_HPP_EAN_20_07_2012 namespace boost { namespace proto { namespace detail { template<typename T> struct static_const { static T const value; }; template<typename T> T const static_const<T>::value = {}; } }} #endif PK �J�[L�d� � detail/as_expr.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file as_expr.hpp /// Contains definition of the as_expr\<\> and as_child\<\> helper class /// templates used to implement proto::domain's as_expr\<\> and as_child\<\> /// member templates. // // Copyright 2010 Eric Niebler. 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_PROTO_DETAIL_AS_EXPR_HPP_EAN_06_09_2010 #define BOOST_PROTO_DETAIL_AS_EXPR_HPP_EAN_06_09_2010 #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/args.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { //////////////////////////////////////////////////////////////////////////////////////////////// template<typename Generator> struct base_generator { typedef Generator type; }; template<typename Generator> struct base_generator<use_basic_expr<Generator> > { typedef Generator type; }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T, typename Generator, bool WantsBasicExpr> struct as_expr; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T, typename Generator> struct as_expr<T, Generator, false> { typedef typename term_traits<T &>::value_type value_type; typedef proto::expr<proto::tag::terminal, term<value_type>, 0> expr_type; typedef typename Generator::template result<Generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(T &t) const { return Generator()(expr_type::make(t)); } }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T, typename Generator> struct as_expr<T, Generator, true> { typedef typename term_traits<T &>::value_type value_type; typedef proto::basic_expr<proto::tag::terminal, term<value_type>, 0> expr_type; typedef typename Generator::template result<Generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(T &t) const { return Generator()(expr_type::make(t)); } }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T> struct as_expr<T, proto::default_generator, false> { typedef typename term_traits<T &>::value_type value_type; typedef proto::expr<proto::tag::terminal, term<value_type>, 0> result_type; BOOST_FORCEINLINE result_type operator()(T &t) const { return result_type::make(t); } }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T> struct as_expr<T, proto::default_generator, true> { typedef typename term_traits<T &>::value_type value_type; typedef proto::basic_expr<proto::tag::terminal, term<value_type>, 0> result_type; BOOST_FORCEINLINE result_type operator()(T &t) const { return result_type::make(t); } }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T, typename Generator, bool WantsBasicExpr> struct as_child; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T, typename Generator> struct as_child<T, Generator, false> { #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) typedef typename term_traits<T &>::reference reference; #else typedef T &reference; #endif typedef proto::expr<proto::tag::terminal, term<reference>, 0> expr_type; typedef typename Generator::template result<Generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(T &t) const { return Generator()(expr_type::make(t)); } }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T, typename Generator> struct as_child<T, Generator, true> { #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) typedef typename term_traits<T &>::reference reference; #else typedef T &reference; #endif typedef proto::basic_expr<proto::tag::terminal, term<reference>, 0> expr_type; typedef typename Generator::template result<Generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(T &t) const { return Generator()(expr_type::make(t)); } }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T> struct as_child<T, proto::default_generator, false> { #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) typedef typename term_traits<T &>::reference reference; #else typedef T &reference; #endif typedef proto::expr<proto::tag::terminal, term<reference>, 0> result_type; BOOST_FORCEINLINE result_type operator()(T &t) const { return result_type::make(t); } }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T> struct as_child<T, proto::default_generator, true> { #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) typedef typename term_traits<T &>::reference reference; #else typedef T &reference; #endif typedef proto::basic_expr<proto::tag::terminal, term<reference>, 0> result_type; BOOST_FORCEINLINE result_type operator()(T &t) const { return result_type::make(t); } }; }}} #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[4<�y detail/as_lvalue.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file as_lvalue.hpp /// Contains definition the as_lvalue() functions. // // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_AS_LVALUE_HPP_EAN_12_27_2007 #define BOOST_PROTO_TRANSFORM_AS_LVALUE_HPP_EAN_12_27_2007 #include <boost/proto/proto_fwd.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { template<typename T> BOOST_FORCEINLINE T &as_lvalue(T &t) { return t; } template<typename T> BOOST_FORCEINLINE T const &as_lvalue(T const &t) { return t; } } }} #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[�:� detail/make_expr.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/make_expr.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_expr.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file make_expr.hpp /// Contains overloads of make_expr() free function. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/make_expr.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else // BOOST_PP_IS_ITERATING #define N BOOST_PP_ITERATION() /// \overload /// template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> BOOST_FORCEINLINE typename lazy_disable_if< is_domain<A0> , result_of::make_expr< Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) > >::type const make_expr(BOOST_PP_ENUM_BINARY_PARAMS(N, const A, &a)) { return proto::detail::make_expr_< Tag , deduce_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) >()(BOOST_PP_ENUM_PARAMS(N, a)); } /// \overload /// template<typename Tag, typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, typename C)> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const C) >::type const make_expr(BOOST_PP_ENUM_BINARY_PARAMS(N, const C, &c)) { return proto::detail::make_expr_< Tag , Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const C) >()(BOOST_PP_ENUM_PARAMS(N, c)); } #undef N #endif PK �J�[#/�� detail/lambda_matches.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/lambda_matches.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_DEFINE_LAMBDA_MATCHES(Z, N, DATA) \ lambda_matches< \ BOOST_PP_CAT(Expr, N) \ , BOOST_PP_CAT(Grammar, N) \ > #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/lambda_matches.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file lambda_matches.hpp /// Specializations of the lambda_matches template // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/lambda_matches.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_DEFINE_LAMBDA_MATCHES #else // BOOST_PP_IS_ITERATING #define N BOOST_PP_ITERATION() template< template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class T BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Expr) BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Grammar) > struct lambda_matches< T<BOOST_PP_ENUM_PARAMS(N, Expr)> , T<BOOST_PP_ENUM_PARAMS(N, Grammar)> BOOST_PROTO_TEMPLATE_ARITY_PARAM(N) > : BOOST_PP_CAT(and_, N)< BOOST_PROTO_DEFINE_LAMBDA_MATCHES(~, 0, ~)::value, BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFINE_LAMBDA_MATCHES, ~) > {}; #undef N #endif PK �J�[լ�R R detail/dont_care.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file dont_care.hpp /// Definintion of dont_care, a dummy parameter // // Copyright 2008 Eric Niebler. 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_PROTO_DETAIL_DONT_CARE_HPP_EAN_11_07_2007 #define BOOST_PROTO_DETAIL_DONT_CARE_HPP_EAN_11_07_2007 #include <boost/config.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { struct dont_care { BOOST_FORCEINLINE dont_care(...); }; } }} #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[�@ e> e> detail/expr.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES #include <boost/proto/detail/preprocessed/expr_variadic.hpp> #else #include <boost/proto/detail/preprocessed/expr.hpp> #endif #elif !defined(BOOST_PP_IS_ITERATING) /// INTERNAL ONLY /// #define BOOST_PROTO_CHILD(Z, N, DATA) \ typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(proto_child, N); \ BOOST_PP_CAT(proto_child, N) BOOST_PP_CAT(child, N); \ /**< INTERNAL ONLY */ /// INTERNAL ONLY /// #define BOOST_PROTO_VOID(Z, N, DATA) \ typedef void BOOST_PP_CAT(proto_child, N); \ /**< INTERNAL ONLY */ // Generate variadic versions of expr #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/expr_variadic.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file expr_variadic.hpp /// Contains definition of expr\<\> class template. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif // The expr<> specializations are actually defined here. #define BOOST_PROTO_DEFINE_TERMINAL #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, 0, <boost/proto/detail/expr.hpp>)) #include BOOST_PP_ITERATE() #undef BOOST_PROTO_DEFINE_TERMINAL #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/expr.hpp>)) #include BOOST_PP_ITERATE() // Generate non-variadic versions of expr #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #define BOOST_NO_CXX11_VARIADIC_TEMPLATES #pragma wave option(preserve: 2, line: 0, output: "preprocessed/expr.hpp") /////////////////////////////////////////////////////////////////////////////// /// \file expr.hpp /// Contains definition of expr\<\> class template. // // Copyright 2008 Eric Niebler. 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) #pragma wave option(preserve: 1) // The expr<> specializations are actually defined here. #define BOOST_PROTO_DEFINE_TERMINAL #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 0, <boost/proto/detail/expr.hpp>)) #include BOOST_PP_ITERATE() #undef BOOST_PROTO_DEFINE_TERMINAL #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/expr.hpp>)) #include BOOST_PP_ITERATE() #pragma wave option(output: null) #undef BOOST_NO_CXX11_VARIADIC_TEMPLATES #endif #undef BOOST_PROTO_CHILD #undef BOOST_PROTO_VOID #else #define ARG_COUNT BOOST_PP_MAX(1, BOOST_PP_ITERATION()) /// \brief Representation of a node in an expression tree. /// /// \c proto::expr\<\> is a node in an expression template tree. It /// is a container for its child sub-trees. It also serves as /// the terminal nodes of the tree. /// /// \c Tag is type that represents the operation encoded by /// this expression. It is typically one of the structs /// in the \c boost::proto::tag namespace, but it doesn't /// have to be. /// /// \c Args is a type list representing the type of the children /// of this expression. It is an instantiation of one /// of \c proto::list1\<\>, \c proto::list2\<\>, etc. The /// child types must all themselves be either \c expr\<\> /// or <tt>proto::expr\<\>&</tt>. If \c Args is an /// instantiation of \c proto::term\<\> then this /// \c expr\<\> type represents a terminal expression; /// the parameter to the \c proto::term\<\> template /// represents the terminal's value type. /// /// \c Arity is an integral constant representing the number of child /// nodes this node contains. If \c Arity is 0, then this /// node is a terminal. /// /// \c proto::expr\<\> is a valid Fusion random-access sequence, where /// the elements of the sequence are the child expressions. #ifdef BOOST_PROTO_DEFINE_TERMINAL template<typename Tag, typename Arg0> struct expr<Tag, term<Arg0>, 0> #else template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(ARG_COUNT, typename Arg)> struct expr<Tag, BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)>, BOOST_PP_ITERATION() > #endif { typedef Tag proto_tag; static const long proto_arity_c = BOOST_PP_ITERATION(); typedef mpl::long_<BOOST_PP_ITERATION() > proto_arity; typedef expr proto_base_expr; #ifdef BOOST_PROTO_DEFINE_TERMINAL typedef term<Arg0> proto_args; #else typedef BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)> proto_args; #endif typedef basic_expr<Tag, proto_args, BOOST_PP_ITERATION() > proto_grammar; typedef default_domain proto_domain; typedef default_generator proto_generator; typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; typedef expr proto_derived_expr; typedef void proto_is_expr_; /**< INTERNAL ONLY */ BOOST_PP_REPEAT(ARG_COUNT, BOOST_PROTO_CHILD, ~) BOOST_PP_REPEAT_FROM_TO(ARG_COUNT, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_VOID, ~) /// \return *this /// BOOST_FORCEINLINE expr const &proto_base() const { return *this; } /// \overload /// BOOST_FORCEINLINE expr &proto_base() { return *this; } #ifdef BOOST_PROTO_DEFINE_TERMINAL /// \return A new \c expr\<\> object initialized with the specified /// arguments. /// template<typename A0> BOOST_FORCEINLINE static expr const make(A0 &a0) { return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0)); } /// \overload /// template<typename A0> BOOST_FORCEINLINE static expr const make(A0 const &a0) { return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0)); } #else /// \return A new \c expr\<\> object initialized with the specified /// arguments. /// template<BOOST_PP_ENUM_PARAMS(ARG_COUNT, typename A)> BOOST_FORCEINLINE static expr const make(BOOST_PP_ENUM_BINARY_PARAMS(ARG_COUNT, A, const &a)) { expr that = {BOOST_PP_ENUM_PARAMS(ARG_COUNT, a)}; return that; } #endif #if 1 == BOOST_PP_ITERATION() /// If \c Tag is \c boost::proto::tag::address_of and \c proto_child0 is /// <tt>T&</tt>, then \c address_of_hack_type_ is <tt>T*</tt>. /// Otherwise, it is some undefined type. typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_; /// \return The address of <tt>this->child0</tt> if \c Tag is /// \c boost::proto::tag::address_of. Otherwise, this function will /// fail to compile. /// /// \attention Proto overloads <tt>operator&</tt>, which means that /// proto-ified objects cannot have their addresses taken, unless we use /// the following hack to make \c &x implicitly convertible to \c X*. BOOST_FORCEINLINE operator address_of_hack_type_() const { return boost::addressof(this->child0); } #else /// INTERNAL ONLY /// typedef detail::not_a_valid_type address_of_hack_type_; #endif /// Assignment /// /// \param a The rhs. /// \return A new \c expr\<\> node representing an assignment of \c that to \c *this. BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > const operator =(expr const &a) { proto::expr< proto::tag::assign , list2<expr &, expr const &> , 2 > that = {*this, a}; return that; } /// Assignment /// /// \param a The rhs. /// \return A new \c expr\<\> node representing an assignment of \c a to \c *this. template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } /// \overload /// template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) const { proto::expr< proto::tag::assign , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } #ifdef BOOST_PROTO_DEFINE_TERMINAL /// \overload /// template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, typename result_of::as_child<A>::type> , 2 > const operator =(A &a) { proto::expr< proto::tag::assign , list2<expr &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } /// \overload /// template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::assign , list2<expr &, typename result_of::as_child<A const>::type> , 2 > const operator =(A const &a) { proto::expr< proto::tag::assign , list2<expr &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } #endif /// Subscript /// /// \param a The rhs. /// \return A new \c expr\<\> node representing \c *this subscripted with \c a. template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } /// \overload /// template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) const { proto::expr< proto::tag::subscript , list2<expr const &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } #ifdef BOOST_PROTO_DEFINE_TERMINAL /// \overload /// template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr &, typename result_of::as_child<A>::type> , 2 > const operator [](A &a) { proto::expr< proto::tag::subscript , list2<expr &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } /// \overload /// template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) { proto::expr< proto::tag::subscript , list2<expr &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } #endif /// Encodes the return type of \c expr\<\>::operator(), for use with \c boost::result_of\<\> /// template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES /// \overload /// template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr const(A const &...) , expr , default_domain >::type const operator ()(A const &... a) const { return result_of::funop< expr const(A const &...) , expr , default_domain >::call(*this, a...); } #ifdef BOOST_PROTO_DEFINE_TERMINAL /// \overload /// template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr(A const &...) , expr , default_domain >::type const operator ()(A const &... a) { return result_of::funop< expr(A const &...) , expr , default_domain >::call(*this, a...); } #endif #else // BOOST_NO_CXX11_VARIADIC_TEMPLATES /// Function call /// /// \return A new \c expr\<\> node representing the function invocation of \c (*this)(). BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr const &>, 1> const operator ()() const { proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; return that; } #ifdef BOOST_PROTO_DEFINE_TERMINAL /// \overload /// BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr &>, 1> const operator ()() { proto::expr<proto::tag::function, list1<expr &>, 1> that = {*this}; return that; } #endif #define BOOST_PP_ITERATION_PARAMS_2 \ (3, (1, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY), <boost/proto/detail/expr_funop.hpp>)) #include BOOST_PP_ITERATE() #endif }; #undef ARG_COUNT #endif PK �J�[UF�_�@ �@ detail/decltype.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file decltype.hpp /// Contains definition the BOOST_PROTO_DECLTYPE_() macro and assorted helpers // // Copyright 2008 Eric Niebler. 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_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008 #define BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008 #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/get_pointer.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/preprocessor/iteration/local.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/mpl/identity.hpp> #include <boost/type_traits/is_class.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/type_traits/is_pointer.hpp> #include <boost/type_traits/is_function.hpp> #include <boost/type_traits/is_member_object_pointer.hpp> #include <boost/type_traits/add_const.hpp> #include <boost/type_traits/add_reference.hpp> #include <boost/typeof/typeof.hpp> #include <boost/utility/addressof.hpp> #include <boost/utility/result_of.hpp> #include <boost/utility/enable_if.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/detail/any.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif // We're STILL using Boost.Typeof on MSVC even for msvc-11.0 because of this bug: // https://connect.microsoft.com/VisualStudio/feedback/details/765392/decltype-of-a-pointer-to-member-operator-gets-ref-qualification-wrong #if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1700)) # define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) typedef decltype((EXPR)) TYPE; #else # define BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(NESTED, EXPR) \ BOOST_TYPEOF_NESTED_TYPEDEF_TPL(BOOST_PP_CAT(nested_and_hidden_, NESTED), EXPR) \ static int const BOOST_PP_CAT(sz, NESTED) = sizeof(boost::proto::detail::check_reference(EXPR));\ struct NESTED \ : boost::mpl::if_c< \ 1 == BOOST_PP_CAT(sz, NESTED) \ , typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type & \ , typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type \ > \ {}; # define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) \ BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(BOOST_PP_CAT(nested_, TYPE), (EXPR)) \ typedef typename BOOST_PP_CAT(nested_, TYPE)::type TYPE; #endif namespace boost { namespace proto { namespace detail { //////////////////////////////////////////////////////////////////////////////////////////// template<typename T> struct as_mutable { typedef T &type; }; template<typename T> struct as_mutable<T &> { typedef T &type; }; template<typename T> struct as_mutable<T const &> { typedef T &type; }; //////////////////////////////////////////////////////////////////////////////////////////// template<typename T> T make(); //////////////////////////////////////////////////////////////////////////////////////////// template<typename T> typename as_mutable<T>::type make_mutable(); //////////////////////////////////////////////////////////////////////////////////////////// template<typename T> struct subscript_wrapper : T { using T::operator[]; #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) any operator[](any const volatile &) const volatile; #else any operator[](any const &) const volatile; #endif }; //////////////////////////////////////////////////////////////////////////////////////////// template<typename T> struct as_subscriptable { typedef typename mpl::if_c< is_class<T>::value , subscript_wrapper<T> , T >::type type; }; template<typename T> struct as_subscriptable<T const> { typedef typename mpl::if_c< is_class<T>::value , subscript_wrapper<T> const , T const >::type type; }; template<typename T> struct as_subscriptable<T &> { typedef typename mpl::if_c< is_class<T>::value , subscript_wrapper<T> & , T & >::type type; }; template<typename T> struct as_subscriptable<T const &> { typedef typename mpl::if_c< is_class<T>::value , subscript_wrapper<T> const & , T const & >::type type; }; //////////////////////////////////////////////////////////////////////////////////////////// template<typename T> typename as_subscriptable<T>::type make_subscriptable(); //////////////////////////////////////////////////////////////////////////////////////////// template<typename T> char check_reference(T &); template<typename T> char (&check_reference(T const &))[2]; namespace has_get_pointerns { using boost::get_pointer; void *(&get_pointer(...))[2]; //////////////////////////////////////////////////////////////////////////////////////////// template<typename T> struct has_get_pointer { static const bool value = sizeof(void *) == sizeof(get_pointer(make<T &>())); typedef mpl::bool_<value> type; }; } using has_get_pointerns::has_get_pointer; //////////////////////////////////////////////////////////////////////////////////////////// template<typename T> struct class_member_traits; template<typename T, typename U> struct class_member_traits<T U::*> { typedef U class_type; typedef T result_type; }; // Other specializations are generated by the preprocessor #include <boost/proto/detail/class_member_traits.hpp> //////////////////////////////////////////////////////////////////////////////////////////// template<typename T> T &lvalue(T &t) { return t; } template<typename T> T const &lvalue(T const &t) { return t; } //////////////////////////////////////////////////////////////////////////////////////////// template<typename U, typename V, typename T> U *proto_get_pointer(T &t, V *, U *) { return boost::addressof(t); } template<typename U, typename V, typename T> U const *proto_get_pointer(T &t, V *, U const *) { return boost::addressof(t); } template<typename U, typename V, typename T> V *proto_get_pointer(T &t, V *, ...) { return get_pointer(t); } //////////////////////////////////////////////////////////////////////////////////////////// #define BOOST_PROTO_USE_GET_POINTER() \ using namespace boost::proto::detail::get_pointerns \ /**/ #define BOOST_PROTO_GET_POINTER(Type, Obj) \ boost::proto::detail::proto_get_pointer<Type>( \ boost::proto::detail::lvalue(Obj) \ , (true ? 0 : get_pointer(Obj)) \ , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(Obj))) \ ) \ /**/ //////////////////////////////////////////////////////////////////////////////////////////// namespace get_pointerns { using boost::get_pointer; template<typename T> typename disable_if_c<has_get_pointer<T>::value, T *>::type get_pointer(T &t) { return boost::addressof(t); } template<typename T> typename disable_if_c<has_get_pointer<T>::value, T const *>::type get_pointer(T const &t) { return boost::addressof(t); } char test_ptr_to_const(void *); char (&test_ptr_to_const(void const *))[2]; template<typename U> char test_V_is_a_U(U *); template<typename U> char test_V_is_a_U(U const *); template<typename U> char (&test_V_is_a_U(...))[2]; //////////////////////////////////////////////////////////////////////////////////////////// // result_of_ is a wrapper around boost::result_of that also handles "invocations" of // member object pointers. template<typename T, typename Void = void> struct result_of_ : BOOST_PROTO_RESULT_OF<T> {}; template<typename T, typename U, typename V> struct result_of_<T U::*(V), typename enable_if_c<is_member_object_pointer<T U::*>::value>::type> { static const bool is_V_a_smart_ptr = 2 == sizeof(test_V_is_a_U<U>(&lvalue(make<V>()))); static const bool is_ptr_to_const = 2 == sizeof(test_ptr_to_const(BOOST_PROTO_GET_POINTER(U, make<V>()))); // If V is not a U, then it is a (smart) pointer and we can always return an lvalue. // Otherwise, we can only return an lvalue if we are given one. typedef typename mpl::eval_if_c< (is_V_a_smart_ptr || is_reference<V>::value) , mpl::eval_if_c< is_ptr_to_const , add_reference<typename add_const<T>::type> , add_reference<T> > , mpl::identity<T> >::type type; }; //////////////////////////////////////////////////////////////////////////////////////////// template< typename T , typename U , bool IsMemPtr = is_member_object_pointer< typename remove_reference<U>::type >::value > struct mem_ptr_fun { BOOST_PROTO_DECLTYPE_( proto::detail::make_mutable<T>() ->* proto::detail::make<U>() , result_type ) result_type operator()( typename add_reference<typename add_const<T>::type>::type t , typename add_reference<typename add_const<U>::type>::type u ) const { return t ->* u; } }; //////////////////////////////////////////////////////////////////////////////////////////// template<typename T, typename U> struct mem_ptr_fun<T, U, true> { typedef typename class_member_traits< typename uncvref<U>::type >::class_type V; BOOST_PROTO_DECLTYPE_( BOOST_PROTO_GET_POINTER(V, proto::detail::make_mutable<T>()) ->* proto::detail::make<U>() , result_type ) result_type operator()( typename add_reference<typename add_const<T>::type>::type t , U u ) const { return BOOST_PROTO_GET_POINTER(V, t) ->* u; } }; } using get_pointerns::result_of_; using get_pointerns::mem_ptr_fun; //////////////////////////////////////////////////////////////////////////////////////////// template<typename A0, typename A1> struct comma_result { BOOST_PROTO_DECLTYPE_((proto::detail::make<A0>(), proto::detail::make<A1>()), type) }; template<typename A0> struct comma_result<A0, void> { typedef void type; }; template<typename A1> struct comma_result<void, A1> { typedef A1 type; }; template<> struct comma_result<void, void> { typedef void type; }; //////////////////////////////////////////////////////////////////////////////////////////// // normalize a function type for use with boost::result_of template<typename T, typename U = T> struct result_of_fixup : mpl::if_c<is_function<T>::value, T *, U> {}; template<typename T, typename U> struct result_of_fixup<T &, U> : result_of_fixup<T, T> {}; template<typename T, typename U> struct result_of_fixup<T const &, U> : result_of_fixup<T, T> {}; template<typename T, typename U> struct result_of_fixup<T *, U> : result_of_fixup<T, U> {}; template<typename R, typename T, typename U> struct result_of_fixup<R T::*, U> { typedef R T::*type; }; template<typename T, typename U> struct result_of_fixup<T const, U> : result_of_fixup<T, U> {}; //// Tests for result_of_fixup //struct bar {}; //BOOST_MPL_ASSERT((is_same<bar, result_of_fixup<bar>::type>)); //BOOST_MPL_ASSERT((is_same<bar const, result_of_fixup<bar const>::type>)); //BOOST_MPL_ASSERT((is_same<bar, result_of_fixup<bar &>::type>)); //BOOST_MPL_ASSERT((is_same<bar const, result_of_fixup<bar const &>::type>)); //BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(*)()>::type>)); //BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(* const)()>::type>)); //BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(* const &)()>::type>)); //BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(&)()>::type>)); template<typename T, typename PMF> struct memfun { typedef typename uncvref<PMF>::type pmf_type; typedef typename class_member_traits<pmf_type>::class_type V; typedef typename class_member_traits<pmf_type>::result_type result_type; memfun(T t, pmf_type p) : obj(t) , pmf(p) {} result_type operator()() const { BOOST_PROTO_USE_GET_POINTER(); return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(); } // Other overloads generated by the preprocessor #include <boost/proto/detail/memfun_funop.hpp> private: T obj; pmf_type pmf; }; } // namespace detail }} #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[�-y& detail/poly_function_traits.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/poly_function_traits.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/poly_function_traits.hpp") #endif /////////////////////////////////////////////////////////////////////////////// // poly_function_traits.hpp // Contains specializations of poly_function_traits and as_mono_function // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/poly_function_traits.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else #define N BOOST_PP_ITERATION() //////////////////////////////////////////////////////////////////////////////////////////////// template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct poly_function_traits<PolyFun, PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), mpl::size_t<sizeof(poly_function_t)> > { typedef typename PolyFun::template impl<BOOST_PP_ENUM_PARAMS(N, const A)> function_type; typedef typename function_type::result_type result_type; }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), true> { typedef typename PolyFun::template impl<BOOST_PP_ENUM_PARAMS(N, const A)> type; }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), false> { typedef PolyFun type; }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct as_mono_function<PolyFun(BOOST_PP_ENUM_PARAMS(N, A))> : as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), is_poly_function<PolyFun>::value> {}; #undef N #endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES PK �J�[ �� detail/local.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file local.hpp /// Contains macros to ease the generation of repetitious code constructs // // Copyright 2008 Eric Niebler. 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_PROTO_LOCAL_MACRO # error "local iteration target macro is not defined" #endif #ifndef BOOST_PROTO_LOCAL_LIMITS # define BOOST_PROTO_LOCAL_LIMITS (1, BOOST_PROTO_MAX_ARITY) #endif #ifndef BOOST_PROTO_LOCAL_typename_A # define BOOST_PROTO_LOCAL_typename_A BOOST_PROTO_typename_A #endif #ifndef BOOST_PROTO_LOCAL_A # define BOOST_PROTO_LOCAL_A BOOST_PROTO_A_const_ref #endif #ifndef BOOST_PROTO_LOCAL_A_a # define BOOST_PROTO_LOCAL_A_a BOOST_PROTO_A_const_ref_a #endif #ifndef BOOST_PROTO_LOCAL_a # define BOOST_PROTO_LOCAL_a BOOST_PROTO_ref_a #endif #define BOOST_PP_LOCAL_LIMITS BOOST_PROTO_LOCAL_LIMITS #define BOOST_PP_LOCAL_MACRO(N) \ BOOST_PROTO_LOCAL_MACRO( \ N \ , BOOST_PROTO_LOCAL_typename_A \ , BOOST_PROTO_LOCAL_A \ , BOOST_PROTO_LOCAL_A_a \ , BOOST_PROTO_LOCAL_a \ ) \ /**/ #include BOOST_PP_LOCAL_ITERATE() #undef BOOST_PROTO_LOCAL_MACRO #undef BOOST_PROTO_LOCAL_LIMITS #undef BOOST_PROTO_LOCAL_typename_A #undef BOOST_PROTO_LOCAL_A #undef BOOST_PROTO_LOCAL_A_a #undef BOOST_PROTO_LOCAL_a PK �J�[� �A A detail/deduce_domain_n.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/deduce_domain_n.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_COMMON_DOMAIN2(Z, N, DATA) \ typedef \ typename common_domain2<common ## N, A ## N>::type \ BOOST_PP_CAT(common, BOOST_PP_INC(N)); \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/deduce_domain_n.hpp") #endif /////////////////////////////////////////////////////////////////////////////// // deduce_domain_n.hpp // Definitions of common_domain[n] and deduce_domain[n] class templates. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (3, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/deduce_domain_n.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_COMMON_DOMAIN2 #else #define N BOOST_PP_ITERATION() template<BOOST_PP_ENUM_PARAMS(N, typename A)> struct BOOST_PP_CAT(common_domain, N) { typedef A0 common1; BOOST_PP_REPEAT_FROM_TO(1, N, BOOST_PROTO_COMMON_DOMAIN2, ~) typedef BOOST_PP_CAT(common, N) type; BOOST_PROTO_ASSERT_VALID_DOMAIN(type); }; template<BOOST_PP_ENUM_PARAMS(N, typename E)> struct BOOST_PP_CAT(deduce_domain, N) : BOOST_PP_CAT(common_domain, N)< BOOST_PP_ENUM_BINARY_PARAMS( N , typename domain_of<E, >::type BOOST_PP_INTERCEPT ) > {}; #undef N #endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES PK �J�[��Ԏ� � detail/remove_typename.hppnu �[��� //============================================================================== // Copyright 2003 - 2011 LASMEA UMR 6602 CNRS/Univ. Clermont II // Copyright 2009 - 2011 LRI UMR 8623 CNRS/Univ Paris Sud XI // Copyright 2011 Eric Niebler // // Distributed under the Boost Software License, Version 1.0. // See accompanying file LICENSE.txt or copy at // http://www.boost.org/LICENSE_1_0.txt //============================================================================== #ifndef BOOST_PROTO_PREPROCESSOR_REMOVE_TYPENAME_HPP_INCLUDED #define BOOST_PROTO_PREPROCESSOR_REMOVE_TYPENAME_HPP_INCLUDED /*! * \file * \brief Defines the BOOST_PROTO_REMOVE_TYPENAME macro */ #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/expand.hpp> #include <boost/preprocessor/tuple/eat.hpp> #include <boost/preprocessor/control/iif.hpp> #include <boost/preprocessor/detail/is_unary.hpp> //============================================================================== // Boost.Preprocessor author P. Mensodines confirmed on an Boost email thread // (subject ``check if a token is a keyword (was "BOOST_PP_IS_UNARY()")'') // that it is OK to used `PP_IS_UNARY()` to check if tokens match predefined // "keyword" as it is done by the macros below (even if `PP_IS_UNARY()` is // technically only part of Boost.Preprocessor private API). //============================================================================== //============================================================================== // `checking_prefix ## tokens` expand to unary (e.g., `(1)`) iff `tokens` start // with keyword to check. //============================================================================== #define BOOST_PROTO_DETAILS_KEYWORD_FACILITY_IS_FRONT(T, CHECKING_PREFIX) \ BOOST_PP_IS_UNARY(BOOST_PP_CAT(CHECKING_PREFIX, T)) \ /**/ //============================================================================== // `is_front_macro(tokens)` is 1 iff `tokens` start with keyword to remove. // `removing_prefix ## <keyword-to-remove>` must expand to nothing. //============================================================================== #define BOOST_PROTO_DETAILS_KEYWORD_FACILITY_REMOVE_FRONT(TOKENS, IS_FRONT_MACRO, REMOVING_PREFIX) \ BOOST_PP_EXPAND( /* without EXPAND doesn't expand on MSVC */ \ BOOST_PP_IIF( \ IS_FRONT_MACRO(TOKENS) \ , BOOST_PP_CAT \ , TOKENS BOOST_PP_TUPLE_EAT(2) \ )(REMOVING_PREFIX, TOKENS) \ ) \ /**/ #define BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_IS_typename (1) /* unary */ #define typename_BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_IS (1) /* unary */ #define BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_REMOVE_typename /* nothing */ #define typename_BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_REMOVE /* nothing */ #define BOOST_PROTO_DETAILS_KEYWORD_IS_TYPENAME_FRONT(TOKENS) \ BOOST_PROTO_DETAILS_KEYWORD_FACILITY_IS_FRONT(TOKENS, BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_IS_) \ /**/ //============================================================================== /*! * \ingroup preprocessor * For any symbol \c X, this macro returns the same symbol from which a potential * leading \c typename keyword has been removed. If no typename keyword is present, * this macros evaluates to \c X itself without error. * * The original implementation of this macro is from Lorenzo Caminiti. * * \param X Symbol to remove \c typename from */ //============================================================================== #define BOOST_PROTO_REMOVE_TYPENAME(X) \ BOOST_PROTO_DETAILS_KEYWORD_FACILITY_REMOVE_FRONT( \ X \ , BOOST_PROTO_DETAILS_KEYWORD_IS_TYPENAME_FRONT \ , BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_REMOVE_ \ ) \ /**/ #endif PK �J�[��qD detail/poly_function.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file poly_function.hpp /// A wrapper that makes a tr1-style function object that handles const /// and non-const refs and reference_wrapper arguments, too, and forwards /// the arguments on to the specified implementation. // // Copyright 2008 Eric Niebler. 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_PROTO_DETAIL_POLY_FUNCTION_EAN_2008_05_02 #define BOOST_PROTO_DETAIL_POLY_FUNCTION_EAN_2008_05_02 #include <boost/ref.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/void.hpp> #include <boost/mpl/size_t.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/detail/is_noncopyable.hpp> #ifdef _MSC_VER # pragma warning(push) # pragma warning(disable: 4181) // const applied to reference type #endif namespace boost { namespace proto { namespace detail { //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T> struct normalize_arg { typedef typename mpl::if_c<is_noncopyable<T>::value, T &, T>::type type; typedef T &reference; }; template<typename T> struct normalize_arg<T const> { typedef typename mpl::if_c<is_noncopyable<T>::value, T const &, T>::type type; typedef T const &reference; }; template<typename T> struct normalize_arg<T &> { typedef typename mpl::if_c<is_noncopyable<T>::value, T &, T>::type type; typedef T &reference; }; template<typename T> struct normalize_arg<T const &> { typedef typename mpl::if_c<is_noncopyable<T>::value, T const &, T>::type type; typedef T const &reference; }; template<typename T> struct normalize_arg<boost::reference_wrapper<T> > { typedef T &type; typedef T &reference; }; template<typename T> struct normalize_arg<boost::reference_wrapper<T> const> { typedef T &type; typedef T &reference; }; template<typename T> struct normalize_arg<boost::reference_wrapper<T> &> { typedef T &type; typedef T &reference; }; template<typename T> struct normalize_arg<boost::reference_wrapper<T> const &> { typedef T &type; typedef T &reference; }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T> struct arg { typedef T const &type; arg(type t) : value(t) {} operator type() const { return this->value; } type operator()() const { return this->value; } BOOST_DELETED_FUNCTION(arg &operator =(arg const &)) private: type value; }; template<typename T> struct arg<T &> { typedef T &type; arg(type t) : value(t) {} operator type() const { return this->value; } type operator()() const { return this->value; } BOOST_DELETED_FUNCTION(arg &operator =(arg const &)) private: type value; }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T, typename Void = void> struct is_poly_function : mpl::false_ {}; template<typename T> struct is_poly_function<T, typename T::is_poly_function_base_> : mpl::true_ {}; //////////////////////////////////////////////////////////////////////////////////////////////// #define BOOST_PROTO_POLY_FUNCTION() \ typedef void is_poly_function_base_; \ /**/ //////////////////////////////////////////////////////////////////////////////////////////////// struct poly_function_base { /// INTERNAL ONLY BOOST_PROTO_POLY_FUNCTION() }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename Derived, typename NullaryResult = void> struct poly_function : poly_function_base { template<typename Sig> struct result; template<typename This> struct result<This()> : Derived::template impl<> { typedef typename result::result_type type; }; NullaryResult operator()() const { result<Derived const()> impl; return impl(); } #include <boost/proto/detail/poly_function_funop.hpp> }; template<typename T> struct wrap_t; typedef char poly_function_t; typedef char (&mono_function_t)[2]; typedef char (&unknown_function_t)[3]; template<typename T> poly_function_t test_poly_function(T *, wrap_t<typename T::is_poly_function_base_> * = 0); template<typename T> mono_function_t test_poly_function(T *, wrap_t<typename T::result_type> * = 0); template<typename T> unknown_function_t test_poly_function(T *, ...); //////////////////////////////////////////////////////////////////////////////////////////////// template<typename Fun, typename Sig, typename Switch = mpl::size_t<sizeof(test_poly_function<Fun>(0,0))> > struct poly_function_traits { typedef typename Fun::template result<Sig>::type result_type; typedef Fun function_type; }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename Fun, typename Sig> struct poly_function_traits<Fun, Sig, mpl::size_t<sizeof(mono_function_t)> > { typedef typename Fun::result_type result_type; typedef Fun function_type; }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename PolyFunSig, bool IsPolyFunction> struct as_mono_function_impl; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename PolyFunSig> struct as_mono_function; #include <boost/proto/detail/poly_function_traits.hpp> }}} // namespace boost::proto::detail #ifdef _MSC_VER # pragma warning(pop) #endif #endif PK �J�[�M�a detail/matches_.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/matches_.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_MATCHES_N_FUN(Z, N, DATA) \ matches_< \ typename detail::expr_traits<typename Args1::BOOST_PP_CAT(child, N)>::value_type::proto_derived_expr \ , typename detail::expr_traits<typename Args1::BOOST_PP_CAT(child, N)>::value_type::proto_grammar \ , typename Args2::BOOST_PP_CAT(child, N)::proto_grammar \ > #define BOOST_PROTO_DEFINE_MATCHES(Z, N, DATA) \ matches_< \ Expr \ , BasicExpr \ , typename BOOST_PP_CAT(G, N)::proto_grammar \ > #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/matches_.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file matches_.hpp /// Definitions of matches_ specializations // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (2, BOOST_PP_MAX(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_MAX_LOGICAL_ARITY), <boost/proto/detail/matches_.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_DEFINE_MATCHES #undef BOOST_PROTO_MATCHES_N_FUN #else // BOOST_PP_IS_ITERATING #define N BOOST_PP_ITERATION() #if N <= BOOST_PROTO_MAX_LOGICAL_ARITY // handle proto::or_ template<typename Expr, typename BasicExpr BOOST_PP_ENUM_TRAILING_PARAMS(N, typename G)> struct matches_<Expr, BasicExpr, proto::or_<BOOST_PP_ENUM_PARAMS(N, G)> > : BOOST_PP_CAT(or_, N)< matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, Expr, BasicExpr BOOST_PP_ENUM_TRAILING_PARAMS(N, G) > {}; // handle proto::and_ template<typename Expr, typename BasicExpr, BOOST_PP_ENUM_PARAMS(N, typename G)> struct matches_<Expr, BasicExpr, proto::and_<BOOST_PP_ENUM_PARAMS(N, G)> > : detail::BOOST_PP_CAT(and_, N)< BOOST_PROTO_DEFINE_MATCHES(~, 0, ~)::value, BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFINE_MATCHES, ~) > {}; #endif #if N <= BOOST_PROTO_MAX_ARITY template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, N>, proto::basic_expr<Tag, Args2, N> > : BOOST_PP_CAT(and_, N)< BOOST_PROTO_MATCHES_N_FUN(~, 0, ~)::value, BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_MATCHES_N_FUN, ~) > {}; template<typename Expr, typename Tag, typename Args1, typename Args2> struct matches_< Expr, proto::basic_expr<Tag, Args1, N>, proto::basic_expr<proto::_, Args2, N> > : BOOST_PP_CAT(and_, N)< BOOST_PROTO_MATCHES_N_FUN(~, 0, ~)::value, BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_MATCHES_N_FUN, ~) > {}; #endif #undef N #endif PK �J�[ن[S� � detail/extends_funop.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES BOOST_PROTO_EXTENDS_FUNCTION_() BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) #else #include <boost/proto/detail/preprocessed/extends_funop.hpp> #endif #else #define BOOST_PP_LOCAL_MACRO(N) \ BOOST_PROTO_DEFINE_FUN_OP(1, N, ~) \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) && !defined(BOOST_PROTO_NO_WAVE_OUTPUT) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/extends_funop.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file extends_funop.hpp /// Definitions for extends\<\>::operator() // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) && !defined(BOOST_PROTO_NO_WAVE_OUTPUT) #pragma wave option(preserve: 1) #endif BOOST_PROTO_EXTENDS_FUNCTION_() #define BOOST_PP_LOCAL_LIMITS \ (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY)) #include BOOST_PP_LOCAL_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) && !defined(BOOST_PROTO_NO_WAVE_OUTPUT) #pragma wave option(output: null) #endif #endif PK �J�[b�a�� � detail/template_arity.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file template_arity.hpp /// Replace all nodes stored by reference by nodes stored by value. // // Copyright 2011 Eric Niebler. 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) // // This file is based on a similar one in MPL from Aleksey Gurtovoy. #ifndef BOOST_PROTO_DETAIL_TEMPLATE_ARITY_HPP_EAN_2011_05_07 #define BOOST_PROTO_DETAIL_TEMPLATE_ARITY_HPP_EAN_2011_05_07 // Somewhat indirect definition of BOOST_PROTO_TEMPLATE_ARITY_PARAM is // to overcome a shortcoming of the Wave tool used to generate the // pre-preprocessed headers. #define BOOST_PROTO_TEMPLATE_ARITY_PARAM BOOST_PROTO_TEMPLATE_ARITY_PARAM2 #define BOOST_PROTO_TEMPLATE_ARITY_PARAM2(param) #if defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) || \ (defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)) #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/inc.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/mpl/int.hpp> #include <boost/proto/proto_fwd.hpp> #undef BOOST_PROTO_TEMPLATE_ARITY_PARAM2 #define BOOST_PROTO_TEMPLATE_ARITY_PARAM2(param) , param namespace boost { namespace proto { namespace detail { sized_type<1>::type template_arity_helper(...); // Other overloads generated by the preprocessor #include <boost/proto/detail/template_arity_helper.hpp> template<typename F, int N, int Size> struct template_arity_impl2 : mpl::int_<Size - 1> {}; template<typename F, int N = BOOST_PROTO_MAX_ARITY> struct template_arity : template_arity_impl2< F , N , sizeof(detail::template_arity_helper((F **)0, (mpl::int_<N> *)0)) > {}; template<typename F, int N> struct template_arity_impl2<F, N, 1> : template_arity<F, N-1> {}; template<typename F> struct template_arity_impl2<F, 0, 1> : mpl::int_<-1> {}; }}} #endif // BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING #endif // BOOST_PROTO_DETAIL_TEMPLATE_ARITY_HPP_EAN_2011_05_07 PK �J�[�q�ќ � detail/is_noncopyable.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file is_noncopyable.hpp /// Utility for detecting when types are non-copyable // // Copyright 2008 Eric Niebler. 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_PROTO_DETAIL_IS_NONCOPYABLE_HPP_EAN_19_07_2012 #define BOOST_PROTO_DETAIL_IS_NONCOPYABLE_HPP_EAN_19_07_2012 #include <boost/noncopyable.hpp> #include <boost/mpl/or.hpp> #include <boost/mpl/bool.hpp> #include <boost/type_traits/is_base_of.hpp> #include <boost/type_traits/is_abstract.hpp> #include <boost/type_traits/is_function.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace detail { // All classes derived from std::ios_base have these public nested types, // and are non-copyable. This is an imperfect test, but it's the best we // we can do. template<typename T> yes_type check_is_iostream( typename T::failure * , typename T::Init * , typename T::fmtflags * , typename T::iostate * , typename T::openmode * , typename T::seekdir * ); template<typename T> no_type check_is_iostream(...); template<typename T> struct is_iostream { static bool const value = sizeof(yes_type) == sizeof(check_is_iostream<T>(0,0,0,0,0,0)); typedef mpl::bool_<value> type; }; /// INTERNAL ONLY // This should be a customization point. And it serves the same purpose // as the is_noncopyable trait in Boost.Foreach. template<typename T> struct is_noncopyable : mpl::or_< is_function<T> , is_abstract<T> , is_iostream<T> , is_base_of<noncopyable, T> > {}; template<typename T, std::size_t N> struct is_noncopyable<T[N]> : mpl::true_ {}; }}} #endif PK �J�[د �g# g# detail/traits.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/traits.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_CHILD(Z, N, DATA) \ /** INTERNAL ONLY */ \ typedef BOOST_PP_CAT(DATA, N) BOOST_PP_CAT(proto_child, N); \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/traits.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file traits.hpp /// Definitions of proto::function, proto::nary_expr and proto::result_of::child_c // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/traits.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_CHILD #else // BOOST_PP_IS_ITERATING #define N BOOST_PP_ITERATION() #if N > 0 /// \brief A metafunction for generating function-call expression types, /// a grammar element for matching function-call expressions, and a /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt> /// transform. template<BOOST_PP_ENUM_PARAMS(N, typename A)> struct function #if N != BOOST_PROTO_MAX_ARITY < BOOST_PP_ENUM_PARAMS(N, A) BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT) > #endif : proto::transform< function< BOOST_PP_ENUM_PARAMS(N, A) BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT) > , int > { typedef proto::expr<proto::tag::function, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type; typedef proto::basic_expr<proto::tag::function, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> {}; /// INTERNAL ONLY typedef proto::tag::function proto_tag; BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD, A) BOOST_PP_REPEAT_FROM_TO( N , BOOST_PROTO_MAX_ARITY , BOOST_PROTO_CHILD , detail::if_vararg<BOOST_PP_CAT(A, BOOST_PP_DEC(N))> BOOST_PP_INTERCEPT ) }; /// \brief A metafunction for generating n-ary expression types with a /// specified tag type, /// a grammar element for matching n-ary expressions, and a /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt> /// transform. /// /// Use <tt>nary_expr\<_, vararg\<_\> \></tt> as a grammar element to match any /// n-ary expression; that is, any non-terminal. template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct nary_expr #if N != BOOST_PROTO_MAX_ARITY < Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, A) BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT) > #endif : proto::transform< nary_expr< Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, A) BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT) > , int > { typedef proto::expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type; typedef proto::basic_expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> {}; /// INTERNAL ONLY typedef Tag proto_tag; BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD, A) BOOST_PP_REPEAT_FROM_TO( N , BOOST_PROTO_MAX_ARITY , BOOST_PROTO_CHILD , detail::if_vararg<BOOST_PP_CAT(A, BOOST_PP_DEC(N))> BOOST_PP_INTERCEPT ) }; namespace detail { template< template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class T , BOOST_PP_ENUM_PARAMS(N, typename A) > struct is_callable_<T<BOOST_PP_ENUM_PARAMS(N, A)> BOOST_PROTO_TEMPLATE_ARITY_PARAM(N)> : is_same<BOOST_PP_CAT(A, BOOST_PP_DEC(N)), callable> {}; } #endif namespace result_of { /// \brief A metafunction that returns the type of the Nth child /// of a Proto expression. /// /// A metafunction that returns the type of the Nth child /// of a Proto expression. \c N must be less than /// \c Expr::proto_arity::value. template<typename Expr> struct child_c<Expr, N> { /// Verify that we are not operating on a terminal BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); /// The raw type of the Nth child as it is stored within /// \c Expr. This may be a value or a reference typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type; /// The "value" type of the child, suitable for return by value, /// computed as follows: /// \li <tt>T const &</tt> becomes <tt>T</tt> /// \li <tt>T &</tt> becomes <tt>T</tt> /// \li <tt>T</tt> becomes <tt>T</tt> typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::value_type type; }; template<typename Expr> struct child_c<Expr &, N> { /// Verify that we are not operating on a terminal BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); /// The raw type of the Nth child as it is stored within /// \c Expr. This may be a value or a reference typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type; /// The "reference" type of the child, suitable for return by /// reference, computed as follows: /// \li <tt>T const &</tt> becomes <tt>T const &</tt> /// \li <tt>T &</tt> becomes <tt>T &</tt> /// \li <tt>T</tt> becomes <tt>T &</tt> typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::reference type; /// INTERNAL ONLY /// BOOST_FORCEINLINE static type call(Expr &e) { return e.proto_base().BOOST_PP_CAT(child, N); } }; template<typename Expr> struct child_c<Expr const &, N> { /// Verify that we are not operating on a terminal BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); /// The raw type of the Nth child as it is stored within /// \c Expr. This may be a value or a reference typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type; /// The "const reference" type of the child, suitable for return by /// const reference, computed as follows: /// \li <tt>T const &</tt> becomes <tt>T const &</tt> /// \li <tt>T &</tt> becomes <tt>T &</tt> /// \li <tt>T</tt> becomes <tt>T const &</tt> typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::const_reference type; /// INTERNAL ONLY /// BOOST_FORCEINLINE static type call(Expr const &e) { return e.proto_base().BOOST_PP_CAT(child, N); } }; } #undef N #endif PK �J�[0�Tcb b detail/make_expr_.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/make_expr_.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_expr_.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file make_expr_.hpp /// Contains definition of make_expr_\<\> class template. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif template< typename Tag , typename Domain BOOST_PP_ENUM_TRAILING_BINARY_PARAMS( BOOST_PROTO_MAX_ARITY , typename A , = void BOOST_PP_INTERCEPT ) , typename _ = void > struct make_expr_ {}; template<typename Domain, typename A> struct make_expr_<tag::terminal, Domain, A BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, void BOOST_PP_INTERCEPT)> { typedef typename proto::detail::protoify<A, Domain>::result_type result_type; BOOST_FORCEINLINE result_type operator()(typename add_reference<A>::type a) const { return proto::detail::protoify<A, Domain>()(a); } }; template<typename A> struct make_expr_<tag::terminal, deduce_domain, A BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, void BOOST_PP_INTERCEPT)> : make_expr_<tag::terminal, default_domain, A> {}; #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/make_expr_.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else // BOOST_PP_IS_ITERATING #define N BOOST_PP_ITERATION() #define M BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N) template<typename Tag, typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct make_expr_<Tag, Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, A) BOOST_PP_ENUM_TRAILING_PARAMS(M, void BOOST_PP_INTERCEPT), void> { typedef BOOST_PP_CAT(list, N)< BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD_TYPE, (A, ~, Domain)) > proto_args; typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; typedef typename Domain::proto_generator proto_generator; typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<A, >::type a)) const { expr_type const that = { BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD, (A, a, Domain)) }; return proto_generator()(that); } }; template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct make_expr_<Tag, deduce_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, A) BOOST_PP_ENUM_TRAILING_PARAMS(M, void BOOST_PP_INTERCEPT), void> : make_expr_< Tag , typename BOOST_PP_CAT(deduce_domain, N)<BOOST_PP_ENUM_PARAMS(N, A)>::type BOOST_PP_ENUM_TRAILING_PARAMS(N, A) > {}; #undef N #undef M #endif PK �J�[s_Z�� � detail/generate_by_value.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/detail/preprocessed/generate_by_value.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/generate_by_value.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file generate_by_value.hpp /// Contains definition of by_value_generator_\<\> class template. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/generate_by_value.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else // BOOST_PP_IS_ITERATING #define N BOOST_PP_ITERATION() template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Arg) > struct by_value_generator_< proto::expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)>, N> > { typedef BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)> src_args; typedef BOOST_PP_CAT(list, N)< BOOST_PP_ENUM_BINARY_PARAMS(N, typename uncvref<Arg, >::type BOOST_PP_INTERCEPT) > dst_args; typedef proto::expr<Tag, src_args, N> src_type; typedef proto::expr<Tag, dst_args, N> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { BOOST_PP_ENUM_PARAMS(N, e.child) }; return that; } }; template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Arg) > struct by_value_generator_< proto::basic_expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)>, N> > { typedef BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)> src_args; typedef BOOST_PP_CAT(list, N)< BOOST_PP_ENUM_BINARY_PARAMS(N, typename uncvref<Arg, >::type BOOST_PP_INTERCEPT) > dst_args; typedef proto::basic_expr<Tag, src_args, N> src_type; typedef proto::basic_expr<Tag, dst_args, N> type; BOOST_FORCEINLINE static type const call(src_type const &e) { type that = { BOOST_PP_ENUM_PARAMS(N, e.child) }; return that; } }; #undef N #endif PK �J�[�>�ly= y= detail/deprecated.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file deprecated.hpp /// Definition of the deprecated BOOST_PROTO_DEFINE_FUCTION_TEMPLATE and /// BOOST_PROTO_DEFINE_VARARG_FUCTION_TEMPLATE macros // // Copyright 2008 Eric Niebler. 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_PROTO_DETAIL_DEPRECATED_HPP_EAN_11_25_2008 #define BOOST_PROTO_DETAIL_DEPRECATED_HPP_EAN_11_25_2008 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/arithmetic/inc.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/arithmetic/sub.hpp> #include <boost/preprocessor/punctuation/comma_if.hpp> #include <boost/preprocessor/control/if.hpp> #include <boost/preprocessor/control/expr_if.hpp> #include <boost/preprocessor/comparison/greater.hpp> #include <boost/preprocessor/tuple/elem.hpp> #include <boost/preprocessor/tuple/to_list.hpp> #include <boost/preprocessor/logical/and.hpp> #include <boost/preprocessor/seq/size.hpp> #include <boost/preprocessor/seq/enum.hpp> #include <boost/preprocessor/seq/seq.hpp> #include <boost/preprocessor/seq/to_tuple.hpp> #include <boost/preprocessor/seq/for_each_i.hpp> #include <boost/preprocessor/seq/pop_back.hpp> #include <boost/preprocessor/seq/push_back.hpp> #include <boost/preprocessor/seq/push_front.hpp> #include <boost/preprocessor/list/for_each_i.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> #include <boost/proto/proto_fwd.hpp> /// INTERNAL ONLY /// #define BOOST_PROTO_VARARG_TEMPLATE_AUX_(R, DATA, I, ELEM) \ (ELEM BOOST_PP_CAT(BOOST_PP_CAT(X, DATA), BOOST_PP_CAT(_, I))) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_VARARG_TEMPLATE_YES_(R, DATA, I, ELEM) \ BOOST_PP_LIST_FOR_EACH_I_R( \ R \ , BOOST_PROTO_VARARG_TEMPLATE_AUX_ \ , I \ , BOOST_PP_TUPLE_TO_LIST( \ BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \ , BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(ELEM)) \ ) \ ) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_VARARG_TEMPLATE_NO_(R, DATA, I, ELEM) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_VARARG_TEMPLATE_(R, DATA, I, ELEM) \ BOOST_PP_IF( \ BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \ , BOOST_PROTO_VARARG_TEMPLATE_YES_ \ , BOOST_PROTO_VARARG_TEMPLATE_NO_ \ )(R, DATA, I, ELEM) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_VARARG_TYPE_AUX_(R, DATA, I, ELEM) \ (BOOST_PP_CAT(BOOST_PP_CAT(X, DATA), BOOST_PP_CAT(_, I))) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_TEMPLATE_PARAMS_YES_(R, DATA, I, ELEM) \ < \ BOOST_PP_SEQ_ENUM( \ BOOST_PP_LIST_FOR_EACH_I_R( \ R \ , BOOST_PROTO_VARARG_TYPE_AUX_ \ , I \ , BOOST_PP_TUPLE_TO_LIST( \ BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \ , BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(ELEM)) \ ) \ ) \ ) \ > \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_TEMPLATE_PARAMS_NO_(R, DATA, I, ELEM) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_VARARG_TYPE_(R, DATA, I, ELEM) \ BOOST_PP_COMMA_IF(I) \ BOOST_PP_SEQ_HEAD(ELEM) \ BOOST_PP_IF( \ BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \ , BOOST_PROTO_TEMPLATE_PARAMS_YES_ \ , BOOST_PROTO_TEMPLATE_PARAMS_NO_ \ )(R, DATA, I, ELEM) BOOST_PP_EXPR_IF(BOOST_PP_GREATER(I, 1), const) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_VARARG_AS_EXPR_(R, DATA, I, ELEM) \ BOOST_PP_EXPR_IF( \ BOOST_PP_GREATER(I, 1) \ , (( \ BOOST_PP_SEQ_HEAD(ELEM) \ BOOST_PP_IF( \ BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \ , BOOST_PROTO_TEMPLATE_PARAMS_YES_ \ , BOOST_PROTO_TEMPLATE_PARAMS_NO_ \ )(R, DATA, I, ELEM)() \ )) \ ) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_VARARG_AS_CHILD_(Z, N, DATA) \ (BOOST_PP_CAT(DATA, N)) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_SEQ_PUSH_FRONT(SEQ, ELEM) \ BOOST_PP_SEQ_POP_BACK(BOOST_PP_SEQ_PUSH_FRONT(BOOST_PP_SEQ_PUSH_BACK(SEQ, _dummy_), ELEM)) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_VARARG_AS_PARAM_(Z, N, DATA) \ (BOOST_PP_CAT(DATA, N)) \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_VARARG_FUN_(Z, N, DATA) \ template< \ BOOST_PP_SEQ_ENUM( \ BOOST_PP_SEQ_FOR_EACH_I( \ BOOST_PROTO_VARARG_TEMPLATE_, ~ \ , BOOST_PP_SEQ_PUSH_FRONT( \ BOOST_PROTO_SEQ_PUSH_FRONT( \ BOOST_PP_TUPLE_ELEM(4, 2, DATA) \ , (BOOST_PP_TUPLE_ELEM(4, 3, DATA)) \ ) \ , BOOST_PP_TUPLE_ELEM(4, 1, DATA) \ ) \ ) \ BOOST_PP_REPEAT_ ## Z(N, BOOST_PROTO_VARARG_AS_PARAM_, typename A) \ ) \ > \ typename boost::proto::result_of::make_expr< \ BOOST_PP_SEQ_FOR_EACH_I( \ BOOST_PROTO_VARARG_TYPE_, ~ \ , BOOST_PP_SEQ_PUSH_FRONT( \ BOOST_PROTO_SEQ_PUSH_FRONT( \ BOOST_PP_TUPLE_ELEM(4, 2, DATA) \ , (BOOST_PP_TUPLE_ELEM(4, 3, DATA)) \ ) \ , BOOST_PP_TUPLE_ELEM(4, 1, DATA) \ ) \ ) \ BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT) \ >::type const \ BOOST_PP_TUPLE_ELEM(4, 0, DATA)(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) \ { \ return boost::proto::detail::make_expr_< \ BOOST_PP_SEQ_FOR_EACH_I( \ BOOST_PROTO_VARARG_TYPE_, ~ \ , BOOST_PP_SEQ_PUSH_FRONT( \ BOOST_PROTO_SEQ_PUSH_FRONT( \ BOOST_PP_TUPLE_ELEM(4, 2, DATA) \ , (BOOST_PP_TUPLE_ELEM(4, 3, DATA)) \ ) \ , BOOST_PP_TUPLE_ELEM(4, 1, DATA) \ ) \ ) \ BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT) \ >()( \ BOOST_PP_SEQ_ENUM( \ BOOST_PP_SEQ_FOR_EACH_I( \ BOOST_PROTO_VARARG_AS_EXPR_, ~ \ , BOOST_PP_SEQ_PUSH_FRONT( \ BOOST_PROTO_SEQ_PUSH_FRONT( \ BOOST_PP_TUPLE_ELEM(4, 2, DATA) \ , (BOOST_PP_TUPLE_ELEM(4, 3, DATA)) \ ) \ , BOOST_PP_TUPLE_ELEM(4, 1, DATA) \ ) \ ) \ BOOST_PP_REPEAT_ ## Z(N, BOOST_PROTO_VARARG_AS_CHILD_, a) \ ) \ ); \ } \ /**/ /// \code /// BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE( /// 1 /// , construct /// , boost::proto::default_domain /// , (boost::proto::tag::function) /// , ((op::construct)(typename)(int)) /// ) /// \endcode #define BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(ARGCOUNT, NAME, DOMAIN, TAG, BOUNDARGS) \ BOOST_PP_REPEAT_FROM_TO( \ ARGCOUNT \ , BOOST_PP_INC(ARGCOUNT) \ , BOOST_PROTO_VARARG_FUN_ \ , (NAME, TAG, BOUNDARGS, DOMAIN) \ )\ /**/ /// \code /// BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE( /// construct /// , boost::proto::default_domain /// , (boost::proto::tag::function) /// , ((op::construct)(typename)(int)) /// ) /// \endcode #define BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE(NAME, DOMAIN, TAG, BOUNDARGS) \ BOOST_PP_REPEAT( \ BOOST_PP_SUB(BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), BOOST_PP_SEQ_SIZE(BOUNDARGS)) \ , BOOST_PROTO_VARARG_FUN_ \ , (NAME, TAG, BOUNDARGS, DOMAIN) \ ) \ /**/ #endif PK �J�[Č,5 5 detail/any.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file any.hpp /// Contains definition the detail::any type // // Copyright 2012 Eric Niebler. 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_PROTO_DETAIL_ANY_HPP_EAN_18_07_2012 #define BOOST_PROTO_DETAIL_ANY_HPP_EAN_18_07_2012 #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/proto/proto_fwd.hpp> namespace boost { namespace proto { namespace detail { namespace anyns { //////////////////////////////////////////////////////////////////////////////////////////// struct any { template<typename T> any(T const &) {} any operator[](any); #define M0(Z, N, DATA) any operator()(BOOST_PP_ENUM_PARAMS_Z(Z, N, any BOOST_PP_INTERCEPT)); BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, M0, ~) #undef M0 template<typename T> operator T &() const volatile; any operator+(); any operator-(); any operator*(); any operator&(); any operator~(); any operator!(); any operator++(); any operator--(); any operator++(int); any operator--(int); friend any operator<<(any, any); friend any operator>>(any, any); friend any operator*(any, any); friend any operator/(any, any); friend any operator%(any, any); friend any operator+(any, any); friend any operator-(any, any); friend any operator<(any, any); friend any operator>(any, any); friend any operator<=(any, any); friend any operator>=(any, any); friend any operator==(any, any); friend any operator!=(any, any); friend any operator||(any, any); friend any operator&&(any, any); friend any operator&(any, any); friend any operator|(any, any); friend any operator^(any, any); friend any operator,(any, any); friend any operator->*(any, any); friend any operator<<=(any, any); friend any operator>>=(any, any); friend any operator*=(any, any); friend any operator/=(any, any); friend any operator%=(any, any); friend any operator+=(any, any); friend any operator-=(any, any); friend any operator&=(any, any); friend any operator|=(any, any); friend any operator^=(any, any); }; } using anyns::any; } }} #endif PK �J�[=Z)�iK iK make_expr.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file make_expr.hpp /// Definition of the \c make_expr() and \c unpack_expr() utilities for /// building Proto expression nodes from child nodes or from a Fusion /// sequence of child nodes, respectively. // // Copyright 2008 Eric Niebler. 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_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005 #define BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/arithmetic/inc.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/arithmetic/sub.hpp> #include <boost/preprocessor/punctuation/comma_if.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_shifted_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/ref.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/assert.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits/add_const.hpp> #include <boost/type_traits/add_reference.hpp> #include <boost/type_traits/remove_cv.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/domain.hpp> #include <boost/proto/generate.hpp> #include <boost/fusion/include/at_c.hpp> #include <boost/fusion/include/begin.hpp> #include <boost/fusion/include/next.hpp> #include <boost/fusion/include/value_of.hpp> #include <boost/fusion/include/size.hpp> #include <boost/proto/detail/poly_function.hpp> #include <boost/proto/detail/deprecated.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4180) // qualifier applied to function type has no meaning; ignored # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { /// INTERNAL ONLY /// #define BOOST_PROTO_AS_CHILD_TYPE(Z, N, DATA) \ typename boost::proto::detail::protoify< \ BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, DATA), N) \ , BOOST_PP_TUPLE_ELEM(3, 2, DATA) \ >::result_type \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_AS_CHILD(Z, N, DATA) \ boost::proto::detail::protoify< \ BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, DATA), N) \ , BOOST_PP_TUPLE_ELEM(3, 2, DATA) \ >()(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 1, DATA), N)) \ /**/ namespace detail { template<typename T, typename Domain> struct protoify : Domain::template as_expr<T> {}; template<typename T, typename Domain> struct protoify<T &, Domain> : Domain::template as_child<T> {}; template<typename T, typename Domain> struct protoify<boost::reference_wrapper<T>, Domain> : Domain::template as_child<T> {}; template<typename T, typename Domain> struct protoify<boost::reference_wrapper<T> const, Domain> : Domain::template as_child<T> {}; // Definition of detail::unpack_expr_ #include <boost/proto/detail/unpack_expr_.hpp> // Definition of detail::make_expr_ #include <boost/proto/detail/make_expr_.hpp> } namespace result_of { /// \brief Metafunction that computes the return type of the /// \c make_expr() function, with a domain deduced from the /// domains of the children. /// /// Use the <tt>result_of::make_expr\<\></tt> metafunction to /// compute the return type of the \c make_expr() function. /// /// In this specialization, the domain is deduced from the /// domains of the child types. (If /// <tt>is_domain\<A0\>::value</tt> is \c true, then another /// specialization is selected.) template< typename Tag , BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, typename A) , typename Void1 // = void , typename Void2 // = void > struct make_expr { /// Same as <tt>result_of::make_expr\<Tag, D, A0, ... AN\>::type</tt> /// where \c D is the deduced domain, which is calculated as follows: /// /// For each \c x in <tt>[0,N)</tt> (proceeding in order beginning with /// <tt>x=0</tt>), if <tt>domain_of\<Ax\>::type</tt> is not /// \c default_domain, then \c D is <tt>domain_of\<Ax\>::type</tt>. /// Otherwise, \c D is \c default_domain. typedef typename detail::make_expr_< Tag , deduce_domain BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A) >::result_type type; }; /// \brief Metafunction that computes the return type of the /// \c make_expr() function, within the specified domain. /// /// Use the <tt>result_of::make_expr\<\></tt> metafunction to compute /// the return type of the \c make_expr() function. template< typename Tag , typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, typename A) > struct make_expr< Tag , Domain BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A) , typename Domain::proto_is_domain_ > { /// If \c Tag is <tt>tag::terminal</tt>, then \c type is a /// typedef for <tt>boost::result_of\<Domain(expr\<tag::terminal, /// term\<A0\> \>)\>::type</tt>. /// /// Otherwise, \c type is a typedef for <tt>boost::result_of\<Domain(expr\<Tag, /// listN\< as_child\<A0\>::type, ... as_child\<AN\>::type\>) /// \>::type</tt>, where \c N is the number of non-void template /// arguments, and <tt>as_child\<A\>::type</tt> is evaluated as /// follows: /// /// \li If <tt>is_expr\<A\>::value</tt> is \c true, then the /// child type is \c A. /// \li If \c A is <tt>B &</tt> or <tt>cv boost::reference_wrapper\<B\></tt>, /// and <tt>is_expr\<B\>::value</tt> is \c true, then the /// child type is <tt>B &</tt>. /// \li If <tt>is_expr\<A\>::value</tt> is \c false, then the /// child type is <tt>boost::result_of\<Domain(expr\<tag::terminal, term\<A\> \> /// )\>::type</tt>. /// \li If \c A is <tt>B &</tt> or <tt>cv boost::reference_wrapper\<B\></tt>, /// and <tt>is_expr\<B\>::value</tt> is \c false, then the /// child type is <tt>boost::result_of\<Domain(expr\<tag::terminal, term\<B &\> \> /// )\>::type</tt>. typedef typename detail::make_expr_< Tag , Domain BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A) >::result_type type; }; /// \brief Metafunction that computes the return type of the /// \c unpack_expr() function, with a domain deduced from the /// domains of the children. /// /// Use the <tt>result_of::unpack_expr\<\></tt> metafunction to /// compute the return type of the \c unpack_expr() function. /// /// \c Sequence is a Fusion Forward Sequence. /// /// In this specialization, the domain is deduced from the /// domains of the child types. (If /// <tt>is_domain\<Sequence>::value</tt> is \c true, then another /// specialization is selected.) template< typename Tag , typename Sequence , typename Void1 // = void , typename Void2 // = void > struct unpack_expr { /// Let \c S be the type of a Fusion Random Access Sequence /// equivalent to \c Sequence. Then \c type is the /// same as <tt>result_of::make_expr\<Tag, /// fusion::result_of::value_at_c\<S, 0\>::type, ... /// fusion::result_of::value_at_c\<S, N-1\>::type\>::type</tt>, /// where \c N is the size of \c S. typedef typename detail::unpack_expr_< Tag , deduce_domain , Sequence , fusion::result_of::size<Sequence>::type::value >::type type; }; /// \brief Metafunction that computes the return type of the /// \c unpack_expr() function, within the specified domain. /// /// Use the <tt>result_of::make_expr\<\></tt> metafunction to compute /// the return type of the \c make_expr() function. template<typename Tag, typename Domain, typename Sequence> struct unpack_expr<Tag, Domain, Sequence, typename Domain::proto_is_domain_> { /// Let \c S be the type of a Fusion Random Access Sequence /// equivalent to \c Sequence. Then \c type is the /// same as <tt>result_of::make_expr\<Tag, Domain, /// fusion::result_of::value_at_c\<S, 0\>::type, ... /// fusion::result_of::value_at_c\<S, N-1\>::type\>::type</tt>, /// where \c N is the size of \c S. typedef typename detail::unpack_expr_< Tag , Domain , Sequence , fusion::result_of::size<Sequence>::type::value >::type type; }; } namespace functional { /// \brief A callable function object equivalent to the /// \c proto::make_expr() function. /// /// In all cases, <tt>functional::make_expr\<Tag, Domain\>()(a0, ... aN)</tt> /// is equivalent to <tt>proto::make_expr\<Tag, Domain\>(a0, ... aN)</tt>. /// /// <tt>functional::make_expr\<Tag\>()(a0, ... aN)</tt> /// is equivalent to <tt>proto::make_expr\<Tag\>(a0, ... aN)</tt>. template<typename Tag, typename Domain /* = deduce_domain*/> struct make_expr { BOOST_PROTO_CALLABLE() BOOST_PROTO_POLY_FUNCTION() template<typename Sig> struct result; template<typename This, typename A0> struct result<This(A0)> { typedef typename result_of::make_expr< Tag , Domain , A0 >::type type; }; /// Construct an expression node with tag type \c Tag /// and in the domain \c Domain. /// /// \return <tt>proto::make_expr\<Tag, Domain\>(a0,...aN)</tt> template<typename A0> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , A0 const >::type const operator ()(A0 const &a0) const { return proto::detail::make_expr_< Tag , Domain , A0 const >()(a0); } // Additional overloads generated by the preprocessor ... #include <boost/proto/detail/make_expr_funop.hpp> /// INTERNAL ONLY /// template< BOOST_PP_ENUM_BINARY_PARAMS( BOOST_PROTO_MAX_ARITY , typename A , = void BOOST_PP_INTERCEPT ) > struct impl : detail::make_expr_< Tag , Domain BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A) > {}; }; /// \brief A callable function object equivalent to the /// \c proto::unpack_expr() function. /// /// In all cases, <tt>functional::unpack_expr\<Tag, Domain\>()(seq)</tt> /// is equivalent to <tt>proto::unpack_expr\<Tag, Domain\>(seq)</tt>. /// /// <tt>functional::unpack_expr\<Tag\>()(seq)</tt> /// is equivalent to <tt>proto::unpack_expr\<Tag\>(seq)</tt>. template<typename Tag, typename Domain /* = deduce_domain*/> struct unpack_expr { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Sequence> struct result<This(Sequence)> { typedef typename result_of::unpack_expr< Tag , Domain , typename remove_reference<Sequence>::type >::type type; }; /// Construct an expression node with tag type \c Tag /// and in the domain \c Domain. /// /// \param sequence A Fusion Forward Sequence /// \return <tt>proto::unpack_expr\<Tag, Domain\>(sequence)</tt> template<typename Sequence> BOOST_FORCEINLINE typename result_of::unpack_expr<Tag, Domain, Sequence const>::type const operator ()(Sequence const &sequence) const { return proto::detail::unpack_expr_< Tag , Domain , Sequence const , fusion::result_of::size<Sequence>::type::value >::call(sequence); } }; } // namespace functional /// \brief Construct an expression of the requested tag type /// with a domain and with the specified arguments as children. /// /// This function template may be invoked either with or without /// specifying a \c Domain argument. If no domain is specified, /// the domain is deduced by examining in order the domains of /// the given arguments and taking the first that is not /// \c default_domain, if any such domain exists, or /// \c default_domain otherwise. /// /// Let \c wrap_(x) be defined such that: /// \li If \c x is a <tt>boost::reference_wrapper\<\></tt>, /// \c wrap_(x) is equivalent to <tt>as_child\<Domain\>(x.get())</tt>. /// \li Otherwise, \c wrap_(x) is equivalent to /// <tt>as_expr\<Domain\>(x)</tt>. /// /// Let <tt>make_\<Tag\>(b0,...bN)</tt> be defined as /// <tt>expr\<Tag, listN\<C0,...CN\> \>::make(c0,...cN)</tt> /// where \c Bx is the type of \c bx. /// /// \return <tt>Domain()(make_\<Tag\>(wrap_(a0),...wrap_(aN)))</tt>. template<typename Tag, typename A0> BOOST_FORCEINLINE typename lazy_disable_if< is_domain<A0> , result_of::make_expr< Tag , A0 const > >::type const make_expr(A0 const &a0) { return proto::detail::make_expr_< Tag , deduce_domain , A0 const >()(a0); } /// \overload /// template<typename Tag, typename Domain, typename C0> BOOST_FORCEINLINE typename result_of::make_expr< Tag , Domain , C0 const >::type const make_expr(C0 const &c0) { return proto::detail::make_expr_< Tag , Domain , C0 const >()(c0); } // Additional overloads generated by the preprocessor... #include <boost/proto/detail/make_expr.hpp> /// \brief Construct an expression of the requested tag type /// with a domain and with childres from the specified Fusion /// Forward Sequence. /// /// This function template may be invoked either with or without /// specifying a \c Domain argument. If no domain is specified, /// the domain is deduced by examining in order the domains of the /// elements of \c sequence and taking the first that is not /// \c default_domain, if any such domain exists, or /// \c default_domain otherwise. /// /// Let \c s be a Fusion Random Access Sequence equivalent to \c sequence. /// Let <tt>wrap_\<N\>(s)</tt>, where \c s has type \c S, be defined /// such that: /// \li If <tt>fusion::result_of::value_at_c\<S,N\>::type</tt> is a reference, /// <tt>wrap_\<N\>(s)</tt> is equivalent to /// <tt>as_child\<Domain\>(fusion::at_c\<N\>(s))</tt>. /// \li Otherwise, <tt>wrap_\<N\>(s)</tt> is equivalent to /// <tt>as_expr\<Domain\>(fusion::at_c\<N\>(s))</tt>. /// /// Let <tt>make_\<Tag\>(b0,...bN)</tt> be defined as /// <tt>expr\<Tag, listN\<B0,...BN\> \>::make(b0,...bN)</tt> /// where \c Bx is the type of \c bx. /// /// \param sequence a Fusion Forward Sequence. /// \return <tt>Domain()(make_\<Tag\>(wrap_\<0\>(s),...wrap_\<N-1\>(s)))</tt>, /// where N is the size of \c Sequence. template<typename Tag, typename Sequence> BOOST_FORCEINLINE typename lazy_disable_if< is_domain<Sequence> , result_of::unpack_expr<Tag, Sequence const> >::type const unpack_expr(Sequence const &sequence) { return proto::detail::unpack_expr_< Tag , deduce_domain , Sequence const , fusion::result_of::size<Sequence>::type::value >::call(sequence); } /// \overload /// template<typename Tag, typename Domain, typename Sequence2> BOOST_FORCEINLINE typename result_of::unpack_expr<Tag, Domain, Sequence2 const>::type const unpack_expr(Sequence2 const &sequence2) { return proto::detail::unpack_expr_< Tag , Domain , Sequence2 const , fusion::result_of::size<Sequence2>::type::value >::call(sequence2); } /// INTERNAL ONLY /// template<typename Tag, typename Domain> struct is_callable<functional::make_expr<Tag, Domain> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename Tag, typename Domain> struct is_callable<functional::unpack_expr<Tag, Domain> > : mpl::true_ {}; }} #if defined(_MSC_VER) # pragma warning(pop) #endif #endif // BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005 PK �J�[� qB3 3 expr.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file expr.hpp /// Contains definition of expr\<\> class template. // // Copyright 2008 Eric Niebler. 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_PROTO_EXPR_HPP_EAN_04_01_2005 #define BOOST_PROTO_EXPR_HPP_EAN_04_01_2005 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/selection/max.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/preprocessor/repetition/enum_trailing.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> #include <boost/utility/addressof.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/args.hpp> #include <boost/proto/traits.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4510) // default constructor could not be generated # pragma warning(disable : 4512) // assignment operator could not be generated # pragma warning(disable : 4610) // user defined constructor required # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { struct not_a_valid_type { private: not_a_valid_type() {} }; template<typename Tag, typename Arg> struct address_of_hack { typedef not_a_valid_type type; }; template<typename Expr> struct address_of_hack<proto::tag::address_of, Expr &> { typedef Expr *type; }; template<typename T, typename Expr, typename Arg0> BOOST_FORCEINLINE Expr make_terminal(T &t, Expr *, proto::term<Arg0> *) { Expr that = {t}; return that; } template<typename T, typename Expr, typename Arg0, std::size_t N> BOOST_FORCEINLINE Expr make_terminal(T (&t)[N], Expr *, proto::term<Arg0[N]> *) { Expr that; for(std::size_t i = 0; i < N; ++i) { that.child0[i] = t[i]; } return that; } template<typename T, typename Expr, typename Arg0, std::size_t N> BOOST_FORCEINLINE Expr make_terminal(T const(&t)[N], Expr *, proto::term<Arg0[N]> *) { Expr that; for(std::size_t i = 0; i < N; ++i) { that.child0[i] = t[i]; } return that; } // Work-around for: // https://connect.microsoft.com/VisualStudio/feedback/details/765449/codegen-stack-corruption-using-runtime-checks-when-aggregate-initializing-struct #if BOOST_WORKAROUND(BOOST_MSVC, < 1800) template<typename T, typename Expr, typename C, typename U> BOOST_FORCEINLINE Expr make_terminal(T &t, Expr *, proto::term<U C::*> *) { Expr that; that.child0 = t; return that; } #endif template<typename T, typename U> struct same_cv { typedef U type; }; template<typename T, typename U> struct same_cv<T const, U> { typedef U const type; }; } namespace result_of { /// \brief A helper metafunction for computing the /// return type of \c proto::expr\<\>::operator(). template<typename Sig, typename This, typename Domain> struct funop; #include <boost/proto/detail/funop.hpp> } namespace exprns_ { // This is where the basic_expr specializations are // actually defined: #include <boost/proto/detail/basic_expr.hpp> #if defined(__GNUC__) && __GNUC__ >= 9 || defined(__clang__) && __clang_major__ >= 10 #pragma GCC diagnostic push // The warning cannot be fixed for aggregates // Sadly, GCC currently emits the warning at the use location: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=94492 #pragma GCC diagnostic ignored "-Wdeprecated-copy" #endif // This is where the expr specialization are // actually defined: #include <boost/proto/detail/expr.hpp> #if defined(__GNUC__) && __GNUC__ >= 9 || defined(__clang__) && __clang_major__ >= 10 #pragma GCC diagnostic pop #endif } /// \brief Lets you inherit the interface of an expression /// while hiding from Proto the fact that the type is a Proto /// expression. template<typename Expr> struct unexpr : Expr { BOOST_PROTO_UNEXPR() BOOST_FORCEINLINE explicit unexpr(Expr const &e) : Expr(e) {} using Expr::operator =; }; }} #if defined(_MSC_VER) # pragma warning(pop) #endif #endif // BOOST_PROTO_EXPR_HPP_EAN_04_01_2005 PK �J�[� �C� � eval.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file eval.hpp /// Contains the eval() expression evaluator. // // Copyright 2008 Eric Niebler. 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_PROTO_EVAL_HPP_EAN_03_29_2007 #define BOOST_PROTO_EVAL_HPP_EAN_03_29_2007 #include <boost/proto/proto_fwd.hpp> // BOOST_PROTO_CALLABLE #include <boost/type_traits/remove_reference.hpp> namespace boost { namespace proto { namespace result_of { /// \brief A metafunction for calculating the return type /// of \c proto::eval() given a certain \c Expr and \c Context /// types. /// /// \note The types \c Expr and \c Context should not be /// reference types. They may be cv-qualified, but the /// cv-qualification on the \c Context parameter is ignored. template<typename Expr, typename Context> struct eval { typedef typename Context::template eval<Expr>::result_type type; }; } namespace functional { /// \brief A PolymorphicFunctionObject type for /// evaluating a given Proto expression with a given /// context. struct eval { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Expr, typename Context> struct result<This(Expr, Context)> { typedef typename proto::result_of::eval< typename remove_reference<Expr>::type , typename remove_reference<Context>::type >::type type; }; /// \brief Evaluate a given Proto expression with a given /// context. /// \param expr The Proto expression to evaluate /// \param context The context in which the expression should be /// evaluated. /// \return <tt>typename Context::template eval<Expr>()(expr, context)</tt> template<typename Expr, typename Context> typename proto::result_of::eval<Expr, Context>::type operator ()(Expr &e, Context &ctx) const { return typename Context::template eval<Expr>()(e, ctx); } /// \overload /// template<typename Expr, typename Context> typename proto::result_of::eval<Expr, Context>::type operator ()(Expr &e, Context const &ctx) const { return typename Context::template eval<Expr>()(e, ctx); } /// \overload /// template<typename Expr, typename Context> typename proto::result_of::eval<Expr const, Context>::type operator ()(Expr const &e, Context &ctx) const { return typename Context::template eval<Expr const>()(e, ctx); } /// \overload /// template<typename Expr, typename Context> typename proto::result_of::eval<Expr const, Context>::type operator ()(Expr const &e, Context const &ctx) const { return typename Context::template eval<Expr const>()(e, ctx); } }; } /// \brief Evaluate a given Proto expression with a given /// context. /// \param expr The Proto expression to evaluate /// \param context The context in which the expression should be /// evaluated. /// \return <tt>typename Context::template eval<Expr>()(expr, context)</tt> template<typename Expr, typename Context> typename proto::result_of::eval<Expr, Context>::type eval(Expr &e, Context &ctx) { return typename Context::template eval<Expr>()(e, ctx); } /// \overload /// template<typename Expr, typename Context> typename proto::result_of::eval<Expr, Context>::type eval(Expr &e, Context const &ctx) { return typename Context::template eval<Expr>()(e, ctx); } /// \overload /// template<typename Expr, typename Context> typename proto::result_of::eval<Expr const, Context>::type eval(Expr const &e, Context &ctx) { return typename Context::template eval<Expr const>()(e, ctx); } /// \overload /// template<typename Expr, typename Context> typename proto::result_of::eval<Expr const, Context>::type eval(Expr const &e, Context const &ctx) { return typename Context::template eval<Expr const>()(e, ctx); } }} #endif PK �J�[�W�qE E proto.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file proto.hpp /// Includes all of Proto. // // Copyright 2008 Eric Niebler. 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_PROTO_HPP_EAN_04_01_2005 #define BOOST_PROTO_HPP_EAN_04_01_2005 #include <boost/proto/core.hpp> #include <boost/proto/debug.hpp> #include <boost/proto/context.hpp> #include <boost/proto/transform.hpp> #include <boost/proto/functional.hpp> #endif PK �J�[5[���% �% transform/make.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file make.hpp /// Contains definition of the make<> transform. // // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007 #define BOOST_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007 #include <boost/detail/workaround.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/selection/max.hpp> #include <boost/preprocessor/arithmetic/inc.hpp> #include <boost/mpl/and.hpp> #include <boost/mpl/aux_/has_type.hpp> #include <boost/proto/detail/template_arity.hpp> #include <boost/utility/result_of.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/args.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/proto/transform/detail/pack.hpp> #include <boost/proto/detail/as_lvalue.hpp> #include <boost/proto/detail/ignore_unused.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { template<typename T> struct is_applyable : mpl::and_<is_callable<T>, is_transform<T> > {}; template<typename T, bool HasType = mpl::aux::has_type<T>::value> struct nested_type { typedef typename T::type type; }; template<typename T> struct nested_type<T, false> { typedef T type; }; template<typename T, bool Applied> struct nested_type_if { typedef T type; static bool const applied = false; }; template<typename T> struct nested_type_if<T, true> : nested_type<T> { static bool const applied = true; }; template< typename R , typename Expr, typename State, typename Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(long Arity = detail::template_arity<R>::value) > struct make_ { typedef R type; static bool const applied = false; }; template< typename R , typename Expr, typename State, typename Data , bool IsApplyable = is_applyable<R>::value > struct make_if_ : make_<R, Expr, State, Data> {}; template<typename R, typename Expr, typename State, typename Data> struct make_if_<R, Expr, State, Data, true> : uncvref<typename when<_, R>::template impl<Expr, State, Data>::result_type> { static bool const applied = true; }; #if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0) // work around GCC bug template<typename Tag, typename Args, long N, typename Expr, typename State, typename Data> struct make_if_<proto::expr<Tag, Args, N>, Expr, State, Data, false> { typedef proto::expr<Tag, Args, N> type; static bool const applied = false; }; // work around GCC bug template<typename Tag, typename Args, long N, typename Expr, typename State, typename Data> struct make_if_<proto::basic_expr<Tag, Args, N>, Expr, State, Data, false> { typedef proto::basic_expr<Tag, Args, N> type; static bool const applied = false; }; #endif template<typename Type, bool IsAggregate = detail::is_aggregate_<Type>::value> struct construct_ { typedef Type result_type; BOOST_FORCEINLINE Type operator ()() const { return Type(); } // Other overloads generated by the preprocessor #include <boost/proto/transform/detail/construct_funop.hpp> }; template<typename Type> struct construct_<Type, true> { typedef Type result_type; BOOST_FORCEINLINE Type operator ()() const { return Type(); } // Other overloads generated by the preprocessor #include <boost/proto/transform/detail/construct_pod_funop.hpp> }; } /// \brief A PrimitiveTransform which prevents another PrimitiveTransform /// from being applied in an \c ObjectTransform. /// /// When building higher order transforms with <tt>make\<\></tt> or /// <tt>lazy\<\></tt>, you sometimes would like to build types that /// are parameterized with Proto transforms. In such lambda-style /// transforms, Proto will unhelpfully find all nested transforms /// and apply them, even if you don't want them to be applied. Consider /// the following transform, which will replace the \c _ in /// <tt>Bar<_>()</tt> with <tt>proto::terminal\<int\>::type</tt>: /// /// \code /// template<typename T> /// struct Bar /// {}; /// /// struct Foo /// : proto::when<_, Bar<_>() > /// {}; /// /// proto::terminal<int>::type i = {0}; /// /// int main() /// { /// Foo()(i); /// std::cout << typeid(Foo()(i)).name() << std::endl; /// } /// \endcode /// /// If you actually wanted to default-construct an object of type /// <tt>Bar\<_\></tt>, you would have to protect the \c _ to prevent /// it from being applied. You can use <tt>proto::protect\<\></tt> /// as follows: /// /// \code /// // OK: replace anything with Bar<_>() /// struct Foo /// : proto::when<_, Bar<protect<_> >() > /// {}; /// \endcode template<typename PrimitiveTransform> struct protect : transform<protect<PrimitiveTransform> > { template<typename, typename, typename> struct impl { typedef PrimitiveTransform result_type; }; }; /// \brief A PrimitiveTransform which computes a type by evaluating any /// nested transforms and then constructs an object of that type. /// /// The <tt>make\<\></tt> transform checks to see if \c Object is a template. /// If it is, the template type is disassembled to find nested transforms. /// Proto considers the following types to represent transforms: /// /// \li Function types /// \li Function pointer types /// \li Types for which <tt>proto::is_callable\< type \>::value</tt> is \c true /// /// <tt>boost::result_of\<make\<T\<X0,X1,...\> \>(Expr, State, Data)\>::type</tt> /// is evaluated as follows. For each \c X in <tt>X0,X1,...</tt>, do: /// /// \li If \c X is a template like <tt>U\<Y0,Y1,...\></tt>, then let <tt>X'</tt> /// be <tt>boost::result_of\<make\<U\<Y0,Y1,...\> \>(Expr, State, Data)\>::type</tt> /// (which evaluates this procedure recursively). Note whether any /// substitutions took place during this operation. /// \li Otherwise, if \c X is a transform, then let <tt>X'</tt> be /// <tt>boost::result_of\<when\<_, X\>(Expr, State, Data)\>::type</tt>. /// Note that a substitution took place. /// \li Otherwise, let <tt>X'</tt> be \c X, and note that no substitution /// took place. /// \li If any substitutions took place in any of the above steps and /// <tt>T\<X0',X1',...\></tt> has a nested <tt>::type</tt> typedef, /// the result type is <tt>T\<X0',X1',...\>::type</tt>. /// \li Otherwise, the result type is <tt>T\<X0',X1',...\></tt>. /// /// Note that <tt>when\<\></tt> is implemented in terms of <tt>call\<\></tt> /// and <tt>make\<\></tt>, so the above procedure is evaluated recursively. template<typename Object> struct make : transform<make<Object> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; /// \return <tt>result_type()</tt> BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param , typename impl::state_param , typename impl::data_param ) const { return result_type(); } }; }; /// INTERNAL ONLY template<typename Fun> struct make<detail::msvc_fun_workaround<Fun> > : make<Fun> {}; // Other specializations generated by the preprocessor. #include <boost/proto/transform/detail/make.hpp> #include <boost/proto/transform/detail/make_gcc_workaround.hpp> /// INTERNAL ONLY /// template<typename Object> struct is_callable<make<Object> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename PrimitiveTransform> struct is_callable<protect<PrimitiveTransform> > : mpl::true_ {}; }} #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[��ү� � transform/lazy.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file lazy.hpp /// Contains definition of the lazy<> transform. // // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007 #define BOOST_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007 #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/transform/make.hpp> #include <boost/proto/transform/call.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/proto/transform/detail/pack.hpp> namespace boost { namespace proto { /// \brief A PrimitiveTransform that uses <tt>make\<\></tt> to build /// a CallableTransform, and then uses <tt>call\<\></tt> to apply it. /// /// <tt>lazy\<\></tt> is useful as a higher-order transform, when the /// transform to be applied depends on the current state of the /// transformation. The invocation of the <tt>make\<\></tt> transform /// evaluates any nested transforms, and the resulting type is treated /// as a CallableTransform, which is evaluated with <tt>call\<\></tt>. template<typename Object> struct lazy : transform<lazy<Object> > { template<typename Expr, typename State, typename Data> struct impl : call< typename make<Object>::template impl<Expr, State, Data>::result_type >::template impl<Expr, State, Data> {}; }; /// INTERNAL ONLY template<typename Fun> struct lazy<detail::msvc_fun_workaround<Fun> > : lazy<Fun> {}; #include <boost/proto/transform/detail/lazy.hpp> /// INTERNAL ONLY /// template<typename Object> struct is_callable<lazy<Object> > : mpl::true_ {}; }} #endif PK �J�[l�/�& �& transform/when.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file when.hpp /// Definition of when transform. // // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_WHEN_HPP_EAN_10_29_2007 #define BOOST_PROTO_TRANSFORM_WHEN_HPP_EAN_10_29_2007 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/mpl/at.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/map.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/transform/call.hpp> #include <boost/proto/transform/make.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/proto/transform/env.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { template<typename Grammar, typename R, typename Fun> struct when_impl : transform<when<Grammar, Fun> > { typedef Grammar first; typedef Fun second; typedef typename Grammar::proto_grammar proto_grammar; // Note: do not evaluate is_callable<R> in this scope. // R may be an incomplete type at this point. template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { // OK to evaluate is_callable<R> here. R should be compete by now. typedef typename mpl::if_c< is_callable<R>::value , proto::call<Fun> // "R" is a function to call , proto::make<Fun> // "R" is an object to construct >::type which; typedef typename which::template impl<Expr, State, Data>::result_type result_type; /// Evaluate <tt>R(A0,A1,...)</tt> as a transform either with /// <tt>call\<\></tt> or with <tt>make\<\></tt> depending on /// whether <tt>is_callable\<R\>::value</tt> is \c true or /// \c false. /// /// \param e The current expression /// \param s The current state /// \param d An arbitrary data /// \pre <tt>matches\<Expr, Grammar\>::value</tt> is \c true /// \return <tt>which()(e, s, d)</tt> BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return typename which::template impl<Expr, State, Data>()(e, s, d); } }; }; } /// \brief A grammar element and a PrimitiveTransform that associates /// a transform with the grammar. /// /// Use <tt>when\<\></tt> to override a grammar's default transform /// with a custom transform. It is for used when composing larger /// transforms by associating smaller transforms with individual /// rules in your grammar, as in the following transform which /// counts the number of terminals in an expression. /// /// \code /// // Count the terminals in an expression tree. /// // Must be invoked with initial state == mpl::int_<0>(). /// struct CountLeaves /// : or_< /// when<terminal<_>, mpl::next<_state>()> /// , otherwise<fold<_, _state, CountLeaves> > /// > /// {}; /// \endcode /// /// In <tt>when\<G, T\></tt>, when \c T is a class type it is a /// PrimitiveTransform and the following equivalencies hold: /// /// <tt>boost::result_of\<when\<G,T\>(E,S,V)\>::type</tt> is the same as /// <tt>boost::result_of\<T(E,S,V)\>::type</tt>. /// /// <tt>when\<G,T\>()(e,s,d)</tt> is the same as /// <tt>T()(e,s,d)</tt>. template<typename Grammar, typename PrimitiveTransform /*= Grammar*/> struct when : PrimitiveTransform { typedef Grammar first; typedef PrimitiveTransform second; typedef typename Grammar::proto_grammar proto_grammar; }; /// \brief A specialization that treats function pointer Transforms as /// if they were function type Transforms. /// /// This specialization requires that \c Fun is actually a function type. /// /// This specialization is required for nested transforms such as /// <tt>when\<G, T0(T1(_))\></tt>. In C++, functions that are used as /// parameters to other functions automatically decay to funtion /// pointer types. In other words, the type <tt>T0(T1(_))</tt> is /// indistinguishable from <tt>T0(T1(*)(_))</tt>. This specialization /// is required to handle these nested function pointer type transforms /// properly. template<typename Grammar, typename Fun> struct when<Grammar, Fun *> : when<Grammar, Fun> {}; /// \brief Syntactic sugar for <tt>when\<_, Fun\></tt>, for use /// in grammars to handle all the cases not yet handled. /// /// Use <tt>otherwise\<T\></tt> in your grammars as a synonym for /// <tt>when\<_, T\></tt> as in the following transform which /// counts the number of terminals in an expression. /// /// \code /// // Count the terminals in an expression tree. /// // Must be invoked with initial state == mpl::int_<0>(). /// struct CountLeaves /// : or_< /// when<terminal<_>, mpl::next<_state>()> /// , otherwise<fold<_, _state, CountLeaves> > /// > /// {}; /// \endcode template<typename Fun> struct otherwise : when<_, Fun> {}; namespace envns_ { // Define the transforms global BOOST_PROTO_DEFINE_ENV_VAR(transforms_type, transforms); } using envns_::transforms; /// \brief This specialization uses the Data parameter as a collection /// of transforms that can be indexed by the specified rule. /// /// Use <tt>when\<T, external_transform\></tt> in your code when you would like /// to define a grammar once and use it to evaluate expressions with /// many different sets of transforms. The transforms are found by /// using the Data parameter as a map from rules to transforms. /// /// See \c action_map for an example. template<typename Grammar> struct when<Grammar, external_transform> : proto::transform<when<Grammar, external_transform> > { typedef Grammar first; typedef external_transform second; typedef typename Grammar::proto_grammar proto_grammar; template<typename Expr, typename State, typename Data> struct impl : remove_reference< typename mpl::eval_if_c< proto::result_of::has_env_var<Data, transforms_type>::value , proto::result_of::env_var<Data, transforms_type> , proto::result_of::env_var<Data, data_type> >::type >::type::template when<Grammar>::template impl<Expr, State, Data> {}; }; /// \brief For defining a map of Rule/Transform pairs for use with /// <tt>when\<T, external_transform\></tt> to make transforms external to the grammar /// /// The following code defines a grammar with a couple of external transforms. /// It also defines an action_map that maps from rules to transforms. It then /// passes that transforms map at the Data parameter to the grammar. In this way, /// the behavior of the grammar can be modified post-hoc by passing a different /// action_map. /// /// \code /// struct int_terminal /// : proto::terminal<int> /// {}; /// /// struct char_terminal /// : proto::terminal<char> /// {}; /// /// struct my_grammar /// : proto::or_< /// proto::when< int_terminal, proto::external_transform > /// , proto::when< char_terminal, proto::external_transform > /// , proto::when< /// proto::plus< my_grammar, my_grammar > /// , proto::fold< _, int(), my_grammar > /// > /// > /// {}; /// /// struct my_transforms /// : proto::external_transforms< /// proto::when<int_terminal, print(proto::_value)> /// , proto::when<char_terminal, print(proto::_value)> /// > /// {}; /// /// proto::literal<int> i(1); /// proto::literal<char> c('a'); /// my_transforms trx; /// /// // Evaluate "i+c" using my_grammar with the specified transforms: /// my_grammar()(i + c, 0, trx); /// \endcode template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_MPL_LIMIT_MAP_SIZE, typename T, mpl::na)> struct external_transforms { typedef mpl::map<BOOST_PP_ENUM_PARAMS(BOOST_MPL_LIMIT_MAP_SIZE, T)> map_type; template<typename Rule> struct when : proto::when<_, typename mpl::at<map_type, Rule>::type> {}; }; // Other specializations of proto::when are generated by the preprocessor... #include <boost/proto/transform/detail/when.hpp> /// INTERNAL ONLY /// template<typename Grammar, typename Transform> struct is_callable<when<Grammar, Transform> > : mpl::true_ {}; }} // namespace boost::proto #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[ ��*�M �M transform/env.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// // env.hpp // Helpers for producing and consuming tranform env variables. // // Copyright 2012 Eric Niebler. 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_PROTO_TRANSFORM_ENV_HPP_EAN_18_07_2012 #define BOOST_PROTO_TRANSFORM_ENV_HPP_EAN_18_07_2012 #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/ref.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/type_traits/add_const.hpp> #include <boost/type_traits/add_reference.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/mpl/assert.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/not.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/proto/detail/poly_function.hpp> #include <boost/proto/detail/is_noncopyable.hpp> #ifdef _MSC_VER # pragma warning(push) # pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored #endif namespace boost { namespace proto { namespace detail { template<typename T> struct value_type { typedef typename remove_const<T>::type value; typedef typename add_reference<T>::type reference; typedef typename mpl::if_c<is_noncopyable<T>::value, reference, value>::type type; }; template<typename T> struct value_type<T &> { typedef T &value; typedef T &reference; typedef T &type; }; } #define BOOST_PROTO_DEFINE_ENV_VAR(TAG, NAME) \ struct TAG \ { \ template<typename Value> \ boost::proto::env<TAG, Value &> const \ operator =(boost::reference_wrapper<Value> &value) const \ { \ return boost::proto::env<TAG, Value &>(value.get()); \ } \ template<typename Value> \ boost::proto::env<TAG, Value &> const \ operator =(boost::reference_wrapper<Value> const &value) const \ { \ return boost::proto::env<TAG, Value &>(value.get()); \ } \ template<typename Value> \ typename boost::disable_if_c< \ boost::is_const<Value>::value \ , boost::proto::env<TAG, typename boost::proto::detail::value_type<Value>::type> \ >::type const operator =(Value &value) const \ { \ return boost::proto::env<TAG, typename boost::proto::detail::value_type<Value>::type>(value); \ } \ template<typename Value> \ boost::proto::env<TAG, typename boost::proto::detail::value_type<Value const>::type> const \ operator =(Value const &value) const \ { \ return boost::proto::env<TAG, typename boost::proto::detail::value_type<Value const>::type>(value); \ } \ }; \ \ TAG const NAME = {} \ /**/ namespace envns_ { //////////////////////////////////////////////////////////////////////////////////////////// // env // A transform env is a slot-based storage mechanism, accessible by tag. template<typename Key, typename Value, typename Base /*= empty_env*/> struct env : private Base { private: Value value_; public: typedef Value value_type; typedef typename add_reference<Value>::type reference; typedef typename add_reference<typename add_const<Value>::type>::type const_reference; typedef void proto_environment_; ///< INTERNAL ONLY explicit env(const_reference value, Base const &base = Base()) : Base(base) , value_(value) {} #if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ <= 2) /// INTERNAL ONLY struct found { typedef Value type; typedef typename add_reference<typename add_const<Value>::type>::type const_reference; }; template<typename OtherKey, typename OtherValue = key_not_found> struct lookup : mpl::if_c< is_same<OtherKey, Key>::value , found , typename Base::template lookup<OtherKey, OtherValue> >::type {}; #else /// INTERNAL ONLY template<typename OtherKey, typename OtherValue = key_not_found> struct lookup : Base::template lookup<OtherKey, OtherValue> {}; /// INTERNAL ONLY template<typename OtherValue> struct lookup<Key, OtherValue> { typedef Value type; typedef typename add_reference<typename add_const<Value>::type>::type const_reference; }; #endif // For key-based lookups not intended to fail using Base::operator[]; const_reference operator[](Key) const { return this->value_; } // For key-based lookups that can fail, use the default if key not found. using Base::at; template<typename T> const_reference at(Key, T const &) const { return this->value_; } }; // define proto::data_type type and proto::data global BOOST_PROTO_DEFINE_ENV_VAR(data_type, data); } using envns_::data; namespace functional { //////////////////////////////////////////////////////////////////////////////////////// // as_env struct as_env { BOOST_PROTO_CALLABLE() BOOST_PROTO_POLY_FUNCTION() /// INTERNAL ONLY template<typename T, bool B = is_env<T>::value> struct impl { typedef env<data_type, typename detail::value_type<T>::type> result_type; result_type const operator()(detail::arg<T> t) const { return result_type(t()); } }; /// INTERNAL ONLY template<typename T> struct impl<T, true> { typedef T result_type; typename add_const<T>::type operator()(detail::arg<T> t) const { return t(); } }; template<typename Sig> struct result; template<typename This, typename T> struct result<This(T)> { typedef typename impl<typename detail::normalize_arg<T>::type>::result_type type; }; template<typename T> typename impl<typename detail::normalize_arg<T &>::type>::result_type const operator()(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T)) const { return impl<typename detail::normalize_arg<T &>::type>()( static_cast<typename detail::normalize_arg<T &>::reference>(t) ); } template<typename T> typename impl<typename detail::normalize_arg<T const &>::type>::result_type const operator()(T const &t) const { return impl<typename detail::normalize_arg<T const &>::type>()( static_cast<typename detail::normalize_arg<T const &>::reference>(t) ); } }; //////////////////////////////////////////////////////////////////////////////////////// // has_env_var template<typename Key> struct has_env_var : detail::poly_function<has_env_var<Key> > { BOOST_PROTO_CALLABLE() template<typename Env, bool IsEnv = is_env<Env>::value> struct impl { typedef mpl::not_< is_same< typename remove_reference<Env>::type::template lookup<Key>::type , key_not_found > > result_type; result_type operator()(detail::arg<Env>) const { return result_type(); } }; template<typename Env> struct impl<Env, false> { typedef mpl::false_ result_type; result_type operator()(detail::arg<Env>) const { return result_type(); } }; }; template<> struct has_env_var<data_type> : detail::poly_function<has_env_var<data_type> > { BOOST_PROTO_CALLABLE() template<typename Env, bool IsEnv = is_env<Env>::value> struct impl { typedef mpl::not_< is_same< typename remove_reference<Env>::type::template lookup<data_type>::type , key_not_found > > result_type; result_type operator()(detail::arg<Env>) const { return result_type(); } }; template<typename Env> struct impl<Env, false> { typedef mpl::true_ result_type; result_type operator()(detail::arg<Env>) const { return result_type(); } }; }; //////////////////////////////////////////////////////////////////////////////////////// // env_var template<typename Key> struct env_var : detail::poly_function<env_var<Key> > { BOOST_PROTO_CALLABLE() template<typename Env> struct impl { typedef typename remove_reference<Env>::type::template lookup<Key>::type result_type; result_type operator()(detail::arg<Env> e) const { return e()[Key()]; } }; }; template<> struct env_var<data_type> : detail::poly_function<env_var<data_type> > { BOOST_PROTO_CALLABLE() template<typename Env, bool B = is_env<Env>::value> struct impl { typedef Env result_type; result_type operator()(detail::arg<Env> e) const { return e(); } }; template<typename Env> struct impl<Env, true> { typedef typename remove_reference<Env>::type::template lookup<data_type>::type result_type; result_type operator()(detail::arg<Env> e) const { return e()[proto::data]; } }; }; } namespace result_of { template<typename T> struct as_env : BOOST_PROTO_RESULT_OF<functional::as_env(T)> {}; template<typename Env, typename Key> struct has_env_var : BOOST_PROTO_RESULT_OF<functional::has_env_var<Key>(Env)>::type {}; template<typename Env, typename Key> struct env_var : BOOST_PROTO_RESULT_OF<functional::env_var<Key>(Env)> {}; } //////////////////////////////////////////////////////////////////////////////////////////// // as_env template<typename T> typename proto::result_of::as_env<T &>::type const as_env(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T)) { return proto::functional::as_env()(t); } template<typename T> typename proto::result_of::as_env<T const &>::type const as_env(T const &t) { return proto::functional::as_env()(t); } //////////////////////////////////////////////////////////////////////////////////////////// // has_env_var template<typename Key, typename Env> typename proto::result_of::has_env_var<Env &, Key>::type has_env_var(Env &e BOOST_PROTO_DISABLE_IF_IS_CONST(Env)) { return functional::has_env_var<Key>()(e); } template<typename Key, typename Env> typename proto::result_of::has_env_var<Env const &, Key>::type has_env_var(Env const &e) { return functional::has_env_var<Key>()(e); } //////////////////////////////////////////////////////////////////////////////////////////// // env_var template<typename Key, typename Env> typename proto::result_of::env_var<Env &, Key>::type env_var(Env &e BOOST_PROTO_DISABLE_IF_IS_CONST(Env)) { return functional::env_var<Key>()(e); } template<typename Key, typename Env> typename proto::result_of::env_var<Env const &, Key>::type env_var(Env const &e) { return functional::env_var<Key>()(e); } namespace envns_ { //////////////////////////////////////////////////////////////////////////////////////// // env operator, template<typename T, typename T1, typename V1> inline typename disable_if_c< is_const<T>::value , env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T &>::type)> >::type const operator,(T &t, env<T1, V1> const &head) { return env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T &>::type)>( head[T1()] , proto::as_env(t) ); } template<typename T, typename T1, typename V1> inline env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T const &>::type)> const operator,(T const &t, env<T1, V1> const &head) { return env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T const &>::type)>( head[T1()] , proto::as_env(t) ); } } //////////////////////////////////////////////////////////////////////////////////////////// // _env_var template<typename Key> struct _env_var : proto::transform<_env_var<Key> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename impl::data::template lookup<Key>::type result_type; BOOST_MPL_ASSERT_NOT((is_same<result_type, key_not_found>)); // lookup failed BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::data::template lookup<Key>::const_reference) operator ()( typename impl::expr_param , typename impl::state_param , typename impl::data_param d ) const { return d[Key()]; } }; }; struct _env : transform<_env> { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef Data result_type; BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::data_param) operator ()( typename impl::expr_param , typename impl::state_param , typename impl::data_param d ) const { return d; } }; }; /// INTERNAL ONLY template<typename Key> struct is_callable<_env_var<Key> > : mpl::true_ {}; /// INTERNAL ONLY template<typename Key> struct is_callable<functional::has_env_var<Key> > : mpl::true_ {}; /// INTERNAL ONLY template<typename Key> struct is_callable<functional::env_var<Key> > : mpl::true_ {}; } } #ifdef _MSC_VER # pragma warning(pop) #endif #endif PK �J�[�ˀ/�& �& transform/arg.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file arg.hpp /// Contains definition of the argN transforms. // // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007 #define BOOST_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007 #include <boost/mpl/if.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/type_traits/is_array.hpp> #include <boost/proto/transform/env.hpp> namespace boost { namespace proto { /// \brief A PrimitiveTransform that returns the current expression /// unmodified /// /// Example: /// /// \code /// proto::terminal<int>::type i = {42}; /// proto::terminal<int>::type & j = proto::_expr()(i); /// assert( boost::addressof(i) == boost::addressof(j) ); /// \endcode struct _expr : transform<_expr> { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef Expr result_type; /// Returns the current expression. /// \param e The current expression. /// \return \c e /// \throw nothrow BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param) operator()( typename impl::expr_param e , typename impl::state_param , typename impl::data_param ) const { return e; } }; }; /// \brief A PrimitiveTransform that returns the current state /// unmodified /// /// Example: /// /// \code /// proto::terminal<int>::type i = {42}; /// char ch = proto::_state()(i, 'a'); /// assert( ch == 'a' ); /// \endcode struct _state : transform<_state> { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef State result_type; /// Returns the current state. /// \param s The current state. /// \return \c s /// \throw nothrow BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::state_param) operator ()( typename impl::expr_param , typename impl::state_param s , typename impl::data_param ) const { return s; } }; }; /// \brief A PrimitiveTransform that returns the current data /// unmodified /// /// Example: /// /// \code /// proto::terminal<int>::type i = {42}; /// std::string str("hello"); /// std::string & data = proto::_data()(i, 'a', str); /// assert( &str == &data ); /// \endcode struct _data : transform<_data> { template<typename Expr, typename State, typename Data> struct impl : mpl::if_c< is_env<Data>::value , _env_var<data_type> , _env >::type::template impl<Expr, State, Data> {}; }; /// \brief A PrimitiveTransform that returns N-th child of the current /// expression. /// /// Example: /// /// \code /// proto::terminal<int>::type i = {42}; /// proto::terminal<int>::type & j = proto::_child_c<0>()(-i); /// assert( boost::addressof(i) == boost::addressof(j) ); /// \endcode template<int N> struct _child_c : transform<_child_c<N> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename result_of::child_c<Expr, N>::type result_type; /// Returns the N-th child of \c e /// \pre <tt>arity_of\<Expr\>::value \> N</tt> /// \param e The current expression. /// \return <tt>proto::child_c\<N\>(e)</tt> /// \throw nothrow #ifdef BOOST_PROTO_STRICT_RESULT_OF result_type #else typename result_of::child_c<typename impl::expr_param, N>::type #endif operator ()( typename impl::expr_param e , typename impl::state_param , typename impl::data_param ) const { return proto::child_c<N>(e); } }; }; /// \brief A PrimitiveTransform that returns the value of the /// current terminal expression. /// /// Example: /// /// \code /// proto::terminal<int>::type i = {42}; /// int j = proto::_value()(i); /// assert( 42 == j ); /// \endcode struct _value : transform<_value> { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename result_of::value<Expr>::type result_type; /// Returns the value of the specified terminal expression. /// \pre <tt>arity_of\<Expr\>::value == 0</tt>. /// \param e The current expression. /// \return <tt>proto::value(e)</tt> /// \throw nothrow #ifdef BOOST_PROTO_STRICT_RESULT_OF typename mpl::if_c<is_array<result_type>::value, result_type &, result_type>::type #else typename result_of::value<typename impl::expr_param>::type #endif operator ()( typename impl::expr_param e , typename impl::state_param , typename impl::data_param ) const { return proto::value(e); } }; }; /// \brief A PrimitiveTransform that does nothing /// and returns void. struct _void : transform<_void> { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef void result_type; /// Does nothing and returns void void operator ()( typename impl::expr_param , typename impl::state_param , typename impl::data_param ) const {} }; }; /// \brief A unary CallableTransform that wraps its argument /// in a \c boost::reference_wrapper\<\>. /// /// Example: /// /// \code /// proto::terminal<int>::type i = {42}; /// boost::reference_wrapper<proto::terminal<int>::type> j /// = proto::when<_, proto::_byref(_)>()(i); /// assert( boost::addressof(i) == boost::addressof(j.get()) ); /// \endcode struct _byref : callable { template<typename Sig> struct result; template<typename This, typename T> struct result<This(T)> { typedef boost::reference_wrapper<T const> const type; }; template<typename This, typename T> struct result<This(T &)> { typedef boost::reference_wrapper<T> const type; }; /// Wrap the parameter \c t in a \c boost::reference_wrapper\<\> /// \param t The object to wrap /// \return <tt>boost::ref(t)</tt> /// \throw nothrow template<typename T> boost::reference_wrapper<T> const operator ()(T &t) const { return boost::reference_wrapper<T>(t); } /// \overload /// template<typename T> boost::reference_wrapper<T const> const operator ()(T const &t) const { return boost::reference_wrapper<T const>(t); } }; /// \brief A unary CallableTransform that strips references /// and \c boost::reference_wrapper\<\> from its argument. /// /// Example: /// /// \code /// proto::terminal<int>::type i = {42}; /// int j = 67; /// int k = proto::when<_, proto::_byval(proto::_state)>()(i, boost::ref(j)); /// assert( 67 == k ); /// \endcode struct _byval : callable { template<typename Sig> struct result; template<typename This, typename T> struct result<This(T)> { typedef T type; }; template<typename This, typename T> struct result<This(T &)> : result<This(T)> {}; template<typename This, typename T> struct result<This(boost::reference_wrapper<T>)> : result<This(T)> {}; /// \param t The object to unref /// \return <tt>t</tt> /// \throw nothrow template<typename T> T operator ()(T const &t) const { return t; } /// \overload /// template<typename T> T operator ()(boost::reference_wrapper<T> const &t) const { return t; } }; /// INTERNAL ONLY /// template<> struct is_callable<_expr> : mpl::true_ {}; /// INTERNAL ONLY /// template<> struct is_callable<_state> : mpl::true_ {}; /// INTERNAL ONLY /// template<> struct is_callable<_data> : mpl::true_ {}; /// INTERNAL ONLY /// template<int N> struct is_callable<_child_c<N> > : mpl::true_ {}; /// INTERNAL ONLY /// template<> struct is_callable<_value> : mpl::true_ {}; /// INTERNAL ONLY /// template<> struct is_callable<_byref> : mpl::true_ {}; /// INTERNAL ONLY /// template<> struct is_callable<_byval> : mpl::true_ {}; }} #endif PK �J�[�PTE1o 1o transform/default.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file default.hpp /// Contains definition of the _default transform, which gives operators their /// usual C++ meanings and uses Boost.Typeof to deduce return types. // // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008 #define BOOST_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008 #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/arithmetic/add.hpp> #include <boost/preprocessor/arithmetic/sub.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/enum_shifted.hpp> #include <boost/preprocessor/repetition/enum_shifted_params.hpp> #include <boost/ref.hpp> #include <boost/get_pointer.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits/is_member_pointer.hpp> #include <boost/type_traits/is_member_object_pointer.hpp> #include <boost/type_traits/is_member_function_pointer.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/proto/transform/arg.hpp> #include <boost/proto/detail/decltype.hpp> namespace boost { namespace proto { namespace detail { template<typename Grammar, typename Tag> struct default_case : not_<_> {}; template<typename Grammar> struct default_case<Grammar, tag::terminal> : when<terminal<_>, _value> {}; template<typename Grammar> struct default_cases { template<typename Tag> struct case_ : default_case<Grammar, Tag> {}; }; #define BOOST_PROTO_UNARY_DEFAULT_EVAL(OP, TAG, MAKE) \ template<typename Grammar> \ struct BOOST_PP_CAT(default_, TAG) \ : transform<BOOST_PP_CAT(default_, TAG)<Grammar> > \ { \ template<typename Expr, typename State, typename Data> \ struct impl \ : transform_impl<Expr, State, Data> \ { \ private: \ typedef typename result_of::child_c<Expr, 0>::type e0; \ typedef typename Grammar::template impl<e0, State, Data>::result_type r0; \ public: \ BOOST_PROTO_DECLTYPE_(OP proto::detail::MAKE<r0>(), result_type) \ result_type operator ()( \ typename impl::expr_param e \ , typename impl::state_param s \ , typename impl::data_param d \ ) const \ { \ typename Grammar::template impl<e0, State, Data> t0; \ return OP t0(proto::child_c<0>(e), s, d); \ } \ }; \ }; \ \ template<typename Grammar> \ struct default_case<Grammar, tag::TAG> \ : when<unary_expr<tag::TAG, Grammar>, BOOST_PP_CAT(default_, TAG)<Grammar> > \ {}; \ /**/ #define BOOST_PROTO_BINARY_DEFAULT_EVAL(OP, TAG, LMAKE, RMAKE) \ template<typename Grammar> \ struct BOOST_PP_CAT(default_, TAG) \ : transform<BOOST_PP_CAT(default_, TAG)<Grammar> > \ { \ template<typename Expr, typename State, typename Data> \ struct impl \ : transform_impl<Expr, State, Data> \ { \ private: \ typedef typename result_of::child_c<Expr, 0>::type e0; \ typedef typename result_of::child_c<Expr, 1>::type e1; \ typedef typename Grammar::template impl<e0, State, Data>::result_type r0; \ typedef typename Grammar::template impl<e1, State, Data>::result_type r1; \ public: \ BOOST_PROTO_DECLTYPE_( \ proto::detail::LMAKE<r0>() OP proto::detail::RMAKE<r1>() \ , result_type \ ) \ result_type operator ()( \ typename impl::expr_param e \ , typename impl::state_param s \ , typename impl::data_param d \ ) const \ { \ typename Grammar::template impl<e0, State, Data> t0; \ typename Grammar::template impl<e1, State, Data> t1; \ return t0(proto::child_c<0>(e), s, d) \ OP t1(proto::child_c<1>(e), s, d); \ } \ }; \ }; \ \ template<typename Grammar> \ struct default_case<Grammar, tag::TAG> \ : when<binary_expr<tag::TAG, Grammar, Grammar>, BOOST_PP_CAT(default_, TAG)<Grammar> > \ {}; \ /**/ BOOST_PROTO_UNARY_DEFAULT_EVAL(+, unary_plus, make) BOOST_PROTO_UNARY_DEFAULT_EVAL(-, negate, make) BOOST_PROTO_UNARY_DEFAULT_EVAL(*, dereference, make) BOOST_PROTO_UNARY_DEFAULT_EVAL(~, complement, make) BOOST_PROTO_UNARY_DEFAULT_EVAL(&, address_of, make) BOOST_PROTO_UNARY_DEFAULT_EVAL(!, logical_not, make) BOOST_PROTO_UNARY_DEFAULT_EVAL(++, pre_inc, make_mutable) BOOST_PROTO_UNARY_DEFAULT_EVAL(--, pre_dec, make_mutable) BOOST_PROTO_BINARY_DEFAULT_EVAL(<<, shift_left, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(>>, shift_right, make_mutable, make_mutable) BOOST_PROTO_BINARY_DEFAULT_EVAL(*, multiplies, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(/, divides, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(%, modulus, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(+, plus, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(-, minus, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(<, less, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(>, greater, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(<=, less_equal, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(>=, greater_equal, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(==, equal_to, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(!=, not_equal_to, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(||, logical_or, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(&&, logical_and, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(&, bitwise_and, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(|, bitwise_or, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(^, bitwise_xor, make, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(=, assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(<<=, shift_left_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(>>=, shift_right_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(*=, multiplies_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(/=, divides_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(%=, modulus_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(+=, plus_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(-=, minus_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(&=, bitwise_and_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(|=, bitwise_or_assign, make_mutable, make) BOOST_PROTO_BINARY_DEFAULT_EVAL(^=, bitwise_xor_assign, make_mutable, make) #undef BOOST_PROTO_UNARY_DEFAULT_EVAL #undef BOOST_PROTO_BINARY_DEFAULT_EVAL /// INTERNAL ONLY template<typename Grammar, typename Expr, typename State, typename Data> struct is_member_function_invocation : is_member_function_pointer< typename uncvref< typename Grammar::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type >::type > {}; /// INTERNAL ONLY template<typename Grammar, typename Expr, typename State, typename Data, bool IsMemFunCall> struct default_mem_ptr_impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: typedef typename detail::mem_ptr_fun<r0, r1>::result_type result_type; result_type operator ()( typename default_mem_ptr_impl::expr_param e , typename default_mem_ptr_impl::state_param s , typename default_mem_ptr_impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return detail::mem_ptr_fun<r0, r1>()( t0(proto::child_c<0>(e), s, d) , t1(proto::child_c<1>(e), s, d) ); } }; /// INTERNAL ONLY template<typename Grammar, typename Expr, typename State, typename Data> struct default_mem_ptr_impl<Grammar, Expr, State, Data, true> : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: typedef detail::memfun<r0, r1> result_type; result_type const operator ()( typename default_mem_ptr_impl::expr_param e , typename default_mem_ptr_impl::state_param s , typename default_mem_ptr_impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return detail::memfun<r0, r1>( t0(proto::child_c<0>(e), s, d) , t1(proto::child_c<1>(e), s, d) ); } }; template<typename Grammar> struct default_mem_ptr : transform<default_mem_ptr<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : default_mem_ptr_impl< Grammar , Expr , State , Data , is_member_function_invocation<Grammar, Expr, State, Data>::value > {}; }; template<typename Grammar> struct default_case<Grammar, tag::mem_ptr> : when<mem_ptr<Grammar, Grammar>, default_mem_ptr<Grammar> > {}; template<typename Grammar> struct default_post_inc : transform<default_post_inc<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; public: BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() ++, result_type) result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; return t0(proto::child_c<0>(e), s, d) ++; } }; }; template<typename Grammar> struct default_case<Grammar, tag::post_inc> : when<post_inc<Grammar>, default_post_inc<Grammar> > {}; template<typename Grammar> struct default_post_dec : transform<default_post_dec<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; public: BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() --, result_type) result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; return t0(proto::child_c<0>(e), s, d) --; } }; }; template<typename Grammar> struct default_case<Grammar, tag::post_dec> : when<post_dec<Grammar>, default_post_dec<Grammar> > {}; template<typename Grammar> struct default_subscript : transform<default_subscript<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: BOOST_PROTO_DECLTYPE_( proto::detail::make_subscriptable<r0>() [ proto::detail::make<r1>() ] , result_type ) result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) [ t1(proto::child_c<1>(e), s, d) ]; } }; }; template<typename Grammar> struct default_case<Grammar, tag::subscript> : when<subscript<Grammar, Grammar>, default_subscript<Grammar> > {}; template<typename Grammar> struct default_if_else_ { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename result_of::child_c<Expr, 2>::type e2; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; public: BOOST_PROTO_DECLTYPE_( proto::detail::make<r0>() ? proto::detail::make<r1>() : proto::detail::make<r2>() , result_type ) result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; typename Grammar::template impl<e2, State, Data> t2; return t0(proto::child_c<0>(e), s, d) ? t1(proto::child_c<1>(e), s, d) : t2(proto::child_c<2>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::if_else_> : when<if_else_<Grammar, Grammar, Grammar>, default_if_else_<Grammar> > {}; template<typename Grammar> struct default_comma : transform<default_comma<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: typedef typename proto::detail::comma_result<r0, r1>::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) , t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::comma> : when<comma<Grammar, Grammar>, default_comma<Grammar> > {}; template<typename Grammar, typename Expr, typename State, typename Data, long Arity> struct default_function_impl; template<typename Grammar> struct default_function : transform<default_function<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : default_function_impl< Grammar , Expr , State , Data , transform_impl<Expr, State, Data>::expr::proto_arity_c > {}; }; template<typename Grammar> struct default_case<Grammar, tag::function> : when<function<Grammar, vararg<Grammar> >, default_function<Grammar> > {}; #define BOOST_PROTO_DEFAULT_EVAL_TYPE(Z, N, DATA) \ typedef \ typename result_of::child_c<DATA, N>::type \ BOOST_PP_CAT(e, N); \ \ typedef \ typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>::result_type \ BOOST_PP_CAT(r, N); \ /**/ #define BOOST_PROTO_DEFAULT_EVAL(Z, N, DATA) \ typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>()( \ proto::child_c<N>(DATA), s, d \ ) \ /**/ template<typename Grammar, typename Expr, typename State, typename Data> struct default_function_impl<Grammar, Expr, State, Data, 1> : transform_impl<Expr, State, Data> { BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr) typedef typename proto::detail::result_of_fixup<r0>::type function_type; typedef typename BOOST_PROTO_RESULT_OF<function_type()>::type result_type; result_type operator ()( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d ) const { return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)(); } }; template<typename Grammar, typename Expr, typename State, typename Data> struct default_function_impl<Grammar, Expr, State, Data, 2> : transform_impl<Expr, State, Data> { BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr) BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 1, Expr) typedef typename proto::detail::result_of_fixup<r0>::type function_type; typedef typename detail::result_of_<function_type(r1)>::type result_type; result_type operator ()( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d ) const { return this->invoke( e , s , d , is_member_function_pointer<function_type>() , is_member_object_pointer<function_type>() ); } private: result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::false_ , mpl::false_ ) const { return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)(BOOST_PROTO_DEFAULT_EVAL(~, 1, e)); } result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::true_ , mpl::false_ ) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (BOOST_PROTO_DEFAULT_EVAL(~, 1, e))) ->* BOOST_PROTO_DEFAULT_EVAL(~, 0, e) )(); } result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::false_ , mpl::true_ ) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (BOOST_PROTO_DEFAULT_EVAL(~, 1, e))) ->* BOOST_PROTO_DEFAULT_EVAL(~, 0, e) ); } }; #include <boost/proto/transform/detail/default_function_impl.hpp> #undef BOOST_PROTO_DEFAULT_EVAL_TYPE #undef BOOST_PROTO_DEFAULT_EVAL } template<typename Grammar /*= detail::_default*/> struct _default : switch_<detail::default_cases<Grammar> > {}; template<typename Grammar> struct is_callable<_default<Grammar> > : mpl::true_ {}; namespace detail { // Loopy indirection that allows proto::_default<> to be // used without specifying a Grammar argument. struct _default : proto::_default<> {}; } }} #endif PK �J�[� h0�T �T transform/impl.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file impl.hpp /// Contains definition of transform<> and transform_impl<> helpers. // // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_IMPL_HPP_EAN_04_03_2008 #define BOOST_PROTO_TRANSFORM_IMPL_HPP_EAN_04_03_2008 #include <boost/config.hpp> #include <boost/mpl/bool.hpp> #include <boost/type_traits/add_const.hpp> #include <boost/type_traits/add_reference.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/detail/any.hpp> #include <boost/proto/detail/static_const.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace envns_ { //////////////////////////////////////////////////////////////////////////////////////////// struct key_not_found {}; //////////////////////////////////////////////////////////////////////////////////////////// // empty_env struct empty_env { typedef void proto_environment_; template<typename OtherTag, typename OtherValue = key_not_found> struct lookup { typedef OtherValue type; typedef typename add_reference<typename add_const<OtherValue>::type>::type const_reference; }; key_not_found operator[](detail::any) const { return key_not_found(); } template<typename T> T const &at(detail::any, T const &t) const { return t; } }; } //////////////////////////////////////////////////////////////////////////////////////////// // is_env template<typename T, typename Void> struct is_env : mpl::false_ {}; template<typename T> struct is_env<T, typename T::proto_environment_> : mpl::true_ {}; template<typename T> struct is_env<T &, void> : is_env<T> {}; #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES /// INTERNAL ONLY /// #define BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X) \ BOOST_PROTO_CALLABLE() \ typedef X proto_is_transform_; \ typedef PrimitiveTransform transform_type; \ \ template<typename Sig> \ struct result \ { \ typedef typename boost::proto::detail::apply_transform<Sig>::result_type type; \ }; \ \ template<typename Expr> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr &)>::result_type \ operator ()(Expr &e) const \ { \ boost::proto::empty_state s = 0; \ boost::proto::empty_env d; \ return boost::proto::detail::apply_transform<transform_type(Expr &)>()(e, s, d); \ } \ \ template<typename Expr> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr const &)>::result_type \ operator ()(Expr const &e) const \ { \ boost::proto::empty_state s = 0; \ boost::proto::empty_env d; \ return boost::proto::detail::apply_transform<transform_type(Expr const &)>()(e, s, d); \ } \ \ template<typename Expr, typename State> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr &, State &)>::result_type \ operator ()(Expr &e, State &s) const \ { \ boost::proto::empty_env d; \ return boost::proto::detail::apply_transform<transform_type(Expr &, State &)>()(e, s, d); \ } \ \ template<typename Expr, typename State> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr const &, State &)>::result_type \ operator ()(Expr const &e, State &s) const \ { \ boost::proto::empty_env d; \ return boost::proto::detail::apply_transform<transform_type(Expr const &, State &)>()(e, s, d); \ } \ \ template<typename Expr, typename State> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr &, State const &)>::result_type \ operator ()(Expr &e, State const &s) const \ { \ boost::proto::empty_env d; \ return boost::proto::detail::apply_transform<transform_type(Expr &, State const &)>()(e, s, d); \ } \ \ template<typename Expr, typename State> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr const &, State const &)>::result_type \ operator ()(Expr const &e, State const &s) const \ { \ boost::proto::empty_env d; \ return boost::proto::detail::apply_transform<transform_type(Expr const &, State const &)>()(e, s, d); \ } \ \ template<typename Expr, typename State, typename Data> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr &, State &, Data &)>::result_type \ operator ()(Expr &e, State &s, Data &d) const \ { \ return boost::proto::detail::apply_transform<transform_type(Expr &, State &, Data &)>()(e, s, d); \ } \ \ template<typename Expr, typename State, typename Data> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr const &, State &, Data &)>::result_type \ operator ()(Expr const &e, State &s, Data &d) const \ { \ return boost::proto::detail::apply_transform<transform_type(Expr const &, State &, Data &)>()(e, s, d); \ } \ \ template<typename Expr, typename State, typename Data> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr &, State const &, Data &)>::result_type \ operator ()(Expr &e, State const &s, Data &d) const \ { \ return boost::proto::detail::apply_transform<transform_type(Expr &, State const &, Data &)>()(e, s, d); \ } \ \ template<typename Expr, typename State, typename Data> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr const &, State const &, Data &)>::result_type \ operator ()(Expr const &e, State const &s, Data &d) const \ { \ return boost::proto::detail::apply_transform<transform_type(Expr const &, State const &, Data &)>()(e, s, d); \ } \ /**/ #else /// INTERNAL ONLY /// #define BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X) \ BOOST_PROTO_CALLABLE() \ typedef X proto_is_transform_; \ typedef PrimitiveTransform transform_type; \ \ template<typename Sig> \ struct result \ { \ typedef typename boost::proto::detail::apply_transform<Sig>::result_type type; \ }; \ \ template<typename Expr> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr const &)>::result_type \ operator ()(Expr &&e) const \ { \ boost::proto::empty_state s = 0; \ boost::proto::empty_env d; \ return boost::proto::detail::apply_transform<transform_type(Expr const &)>()(e, s, d); \ } \ \ template<typename Expr, typename State> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr const &, State const &)>::result_type \ operator ()(Expr &&e, State &&s) const \ { \ boost::proto::empty_env d; \ return boost::proto::detail::apply_transform<transform_type(Expr const &, State const &)>()(e, s, d); \ } \ \ template<typename Expr, typename State, typename Data> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr const &, State const &, Data const &)>::result_type \ operator ()(Expr &&e, State &&s, Data &&d) const \ { \ return boost::proto::detail::apply_transform<transform_type(Expr const &, State const &, Data const &)>()(e, s, d); \ } \ /**/ #endif #define BOOST_PROTO_TRANSFORM(PrimitiveTransform) \ BOOST_PROTO_TRANSFORM_(PrimitiveTransform, void) \ /**/ namespace detail { template<typename Sig> struct apply_transform; template<typename PrimitiveTransform, typename Expr> struct apply_transform<PrimitiveTransform(Expr)> : PrimitiveTransform::template impl<Expr, empty_state, empty_env> {}; template<typename PrimitiveTransform, typename Expr, typename State> struct apply_transform<PrimitiveTransform(Expr, State)> : PrimitiveTransform::template impl<Expr, State, empty_env> {}; template<typename PrimitiveTransform, typename Expr, typename State, typename Data> struct apply_transform<PrimitiveTransform(Expr, State, Data)> : PrimitiveTransform::template impl<Expr, State, Data> {}; } template<typename PrimitiveTransform, typename X> struct transform { BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X) }; template<typename Expr, typename State, typename Data> struct transform_impl { typedef Expr const expr; typedef Expr const &expr_param; typedef State const state; typedef State const &state_param; typedef Data const data; typedef Data const &data_param; }; template<typename Expr, typename State, typename Data> struct transform_impl<Expr &, State, Data> { typedef Expr expr; typedef Expr &expr_param; typedef State const state; typedef State const &state_param; typedef Data const data; typedef Data const &data_param; }; template<typename Expr, typename State, typename Data> struct transform_impl<Expr, State &, Data> { typedef Expr const expr; typedef Expr const &expr_param; typedef State state; typedef State &state_param; typedef Data const data; typedef Data const &data_param; }; template<typename Expr, typename State, typename Data> struct transform_impl<Expr, State, Data &> { typedef Expr const expr; typedef Expr const &expr_param; typedef State const state; typedef State const &state_param; typedef Data data; typedef Data &data_param; }; template<typename Expr, typename State, typename Data> struct transform_impl<Expr &, State &, Data> { typedef Expr expr; typedef Expr &expr_param; typedef State state; typedef State &state_param; typedef Data const data; typedef Data const &data_param; }; template<typename Expr, typename State, typename Data> struct transform_impl<Expr &, State, Data &> { typedef Expr expr; typedef Expr &expr_param; typedef State const state; typedef State const &state_param; typedef Data data; typedef Data &data_param; }; template<typename Expr, typename State, typename Data> struct transform_impl<Expr, State &, Data &> { typedef Expr const expr; typedef Expr const &expr_param; typedef State state; typedef State &state_param; typedef Data data; typedef Data &data_param; }; template<typename Expr, typename State, typename Data> struct transform_impl<Expr &, State &, Data &> { typedef Expr expr; typedef Expr &expr_param; typedef State state; typedef State &state_param; typedef Data data; typedef Data &data_param; }; }} // namespace boost::proto #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[��Zpu! u! transform/fold.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file fold.hpp /// Contains definition of the fold<> and reverse_fold<> transforms. // // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007 #define BOOST_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/arithmetic/inc.hpp> #include <boost/preprocessor/arithmetic/sub.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/fusion/include/fold.hpp> #include <boost/fusion/include/reverse_fold.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/proto/transform/when.hpp> namespace boost { namespace proto { namespace detail { template<typename Transform, typename Data> struct as_callable { as_callable(Data d) : d_(d) {} template<typename Sig> struct result; template<typename This, typename State, typename Expr> struct result<This(State, Expr)> { typedef typename when<_, Transform>::template impl<Expr, State, Data>::result_type type; }; template<typename State, typename Expr> typename when<_, Transform>::template impl<Expr &, State const &, Data>::result_type operator ()(State const &s, Expr &e) const { return typename when<_, Transform>::template impl<Expr &, State const &, Data>()(e, s, this->d_); } private: Data d_; }; template< typename State0 , typename Fun , typename Expr , typename State , typename Data , long Arity = arity_of<Expr>::value > struct fold_impl {}; template< typename State0 , typename Fun , typename Expr , typename State , typename Data , long Arity = arity_of<Expr>::value > struct reverse_fold_impl {}; #include <boost/proto/transform/detail/fold_impl.hpp> } // namespace detail /// \brief A PrimitiveTransform that invokes the <tt>fusion::fold\<\></tt> /// algorithm to accumulate template<typename Sequence, typename State0, typename Fun> struct fold : transform<fold<Sequence, State0, Fun> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { /// \brief A Fusion sequence. typedef typename remove_reference< typename when<_, Sequence>::template impl<Expr, State, Data>::result_type >::type sequence; /// \brief An initial state for the fold. typedef typename remove_reference< typename when<_, State0>::template impl<Expr, State, Data>::result_type >::type state0; /// \brief <tt>fun(d)(e,s) == when\<_,Fun\>()(e,s,d)</tt> typedef detail::as_callable<Fun, Data> fun; typedef typename fusion::result_of::fold< sequence , state0 , fun >::type result_type; /// Let \c seq be <tt>when\<_, Sequence\>()(e, s, d)</tt>, let /// \c state0 be <tt>when\<_, State0\>()(e, s, d)</tt>, and /// let \c fun(d) be an object such that <tt>fun(d)(e, s)</tt> /// is equivalent to <tt>when\<_, Fun\>()(e, s, d)</tt>. Then, this /// function returns <tt>fusion::fold(seq, state0, fun(d))</tt>. /// /// \param e The current expression /// \param s The current state /// \param d An arbitrary data result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename when<_, Sequence>::template impl<Expr, State, Data> seq; detail::as_callable<Fun, Data> f(d); return fusion::fold( seq(e, s, d) , typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d) , f ); } }; }; /// \brief A PrimitiveTransform that is the same as the /// <tt>fold\<\></tt> transform, except that it folds /// back-to-front instead of front-to-back. template<typename Sequence, typename State0, typename Fun> struct reverse_fold : transform<reverse_fold<Sequence, State0, Fun> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { /// \brief A Fusion sequence. typedef typename remove_reference< typename when<_, Sequence>::template impl<Expr, State, Data>::result_type >::type sequence; /// \brief An initial state for the fold. typedef typename remove_reference< typename when<_, State0>::template impl<Expr, State, Data>::result_type >::type state0; /// \brief <tt>fun(d)(e,s) == when\<_,Fun\>()(e,s,d)</tt> typedef detail::as_callable<Fun, Data> fun; typedef typename fusion::result_of::reverse_fold< sequence , state0 , fun >::type result_type; /// Let \c seq be <tt>when\<_, Sequence\>()(e, s, d)</tt>, let /// \c state0 be <tt>when\<_, State0\>()(e, s, d)</tt>, and /// let \c fun(d) be an object such that <tt>fun(d)(e, s)</tt> /// is equivalent to <tt>when\<_, Fun\>()(e, s, d)</tt>. Then, this /// function returns <tt>fusion::fold(seq, state0, fun(d))</tt>. /// /// \param e The current expression /// \param s The current state /// \param d An arbitrary data result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename when<_, Sequence>::template impl<Expr, State, Data> seq; detail::as_callable<Fun, Data> f(d); return fusion::reverse_fold( seq(e, s, d) , typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d) , f ); } }; }; // This specialization is only for improved compile-time performance // in the commom case when the Sequence transform is \c proto::_. // /// INTERNAL ONLY /// template<typename State0, typename Fun> struct fold<_, State0, Fun> : transform<fold<_, State0, Fun> > { template<typename Expr, typename State, typename Data> struct impl : detail::fold_impl<State0, Fun, Expr, State, Data> {}; }; // This specialization is only for improved compile-time performance // in the commom case when the Sequence transform is \c proto::_. // /// INTERNAL ONLY /// template<typename State0, typename Fun> struct reverse_fold<_, State0, Fun> : transform<reverse_fold<_, State0, Fun> > { template<typename Expr, typename State, typename Data> struct impl : detail::reverse_fold_impl<State0, Fun, Expr, State, Data> {}; }; /// INTERNAL ONLY /// template<typename Sequence, typename State, typename Fun> struct is_callable<fold<Sequence, State, Fun> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename Sequence, typename State, typename Fun> struct is_callable<reverse_fold<Sequence, State, Fun> > : mpl::true_ {}; }} #endif PK �J�[o ��� � transform/integral_c.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file integral_c.hpp /// Contains definition of the integral_c transform and friends. // // Copyright 2011 Eric Niebler. 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_PROTO_TRANSFORM_INTEGRAL_C_HPP_EAN_04_28_2011 #define BOOST_PROTO_TRANSFORM_INTEGRAL_C_HPP_EAN_04_28_2011 #include <boost/proto/proto_fwd.hpp> #include <boost/proto/transform/impl.hpp> namespace boost { namespace proto { /// \brief A PrimitiveTransform that returns a specified /// integral constant /// template<typename T, T I> struct integral_c : transform<integral_c<T, I> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef T result_type; /// \return \c I /// \throw nothrow T operator()( typename impl::expr_param , typename impl::state_param , typename impl::data_param ) const { return I; } }; }; /// \brief A PrimitiveTransform that returns a specified /// char /// template<char I> struct char_ : integral_c<char, I> {}; /// \brief A PrimitiveTransform that returns a specified /// int /// template<int I> struct int_ : integral_c<int, I> {}; /// \brief A PrimitiveTransform that returns a specified /// long /// template<long I> struct long_ : integral_c<long, I> {}; /// \brief A PrimitiveTransform that returns a specified /// std::size_t /// template<std::size_t I> struct size_t : integral_c<std::size_t, I> {}; /// INTERNAL ONLY /// template<typename T, T I> struct is_callable<integral_c<T, I> > : mpl::true_ {}; /// INTERNAL ONLY /// template<char I> struct is_callable<char_<I> > : mpl::true_ {}; /// INTERNAL ONLY /// template<int I> struct is_callable<int_<I> > : mpl::true_ {}; /// INTERNAL ONLY /// template<long I> struct is_callable<long_<I> > : mpl::true_ {}; /// INTERNAL ONLY /// template<std::size_t I> struct is_callable<size_t<I> > : mpl::true_ {}; }} #endif PK �J�[�&��� � transform/detail/make.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/transform/detail/preprocessed/make.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_MAKE_IF(Z, M, DATA) \ make_if_<BOOST_PP_CAT(A, M), Expr, State, Data> \ /**/ #define BOOST_PROTO_MAKE_IF_TYPE(Z, M, DATA) \ typename BOOST_PROTO_MAKE_IF(Z, M, DATA) ::type \ /**/ #define BOOST_PROTO_MAKE_IF_APPLIED(Z, M, DATA) \ BOOST_PROTO_MAKE_IF(Z, M, DATA) ::applied || \ /**/ #define BOOST_PROTO_CONSTRUCT_ARG(Z, M, DATA) \ detail::as_lvalue( \ typename when<_, BOOST_PP_CAT(A, M)>::template impl<Expr, State, Data>()(e, s, d) \ ) \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/make.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file make.hpp /// Contains definition of the make<> transform. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/make.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_CONSTRUCT_ARG #undef BOOST_PROTO_MAKE_IF_APPLIED #undef BOOST_PROTO_MAKE_IF_TYPE #undef BOOST_PROTO_MAKE_IF #else #define N BOOST_PP_ITERATION() namespace detail { #if N > 0 template< template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A) , typename Expr, typename State, typename Data > struct make_< R<BOOST_PP_ENUM_PARAMS(N, A)> , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(N) > : nested_type_if< R<BOOST_PP_ENUM(N, BOOST_PROTO_MAKE_IF_TYPE, ~)> , (BOOST_PP_REPEAT(N, BOOST_PROTO_MAKE_IF_APPLIED, ~) false) > {}; template< template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A) , typename Expr, typename State, typename Data > struct make_< noinvoke<R<BOOST_PP_ENUM_PARAMS(N, A)> > , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) > { typedef R<BOOST_PP_ENUM(N, BOOST_PROTO_MAKE_IF_TYPE, ~)> type; static bool const applied = true; }; #endif template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct is_applyable<R(BOOST_PP_ENUM_PARAMS(N, A))> : mpl::true_ {}; template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct is_applyable<R(*)(BOOST_PP_ENUM_PARAMS(N, A))> : mpl::true_ {}; template<typename T, typename A> struct construct_<proto::expr<T, A, N>, true> { typedef proto::expr<T, A, N> result_type; template<BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), typename A)> BOOST_FORCEINLINE result_type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_MAX(N, 1), A, &a)) const { return result_type::make(BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), a)); } }; template<typename T, typename A> struct construct_<proto::basic_expr<T, A, N>, true> { typedef proto::basic_expr<T, A, N> result_type; template<BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), typename A)> BOOST_FORCEINLINE result_type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_MAX(N, 1), A, &a)) const { return result_type::make(BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), a)); } }; template<typename Type BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> BOOST_FORCEINLINE Type construct(BOOST_PP_ENUM_BINARY_PARAMS(N, A, &a)) { return construct_<Type>()(BOOST_PP_ENUM_PARAMS(N, a)); } } // namespace detail /// \brief A PrimitiveTransform which computes a type by evaluating any /// nested transforms and then constructs an object of that type with the /// current expression, state and data, transformed according /// to \c A0 through \c AN. template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct make<Object(BOOST_PP_ENUM_PARAMS(N, A))> : transform<make<Object(BOOST_PP_ENUM_PARAMS(N, A))> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { /// \brief <tt>boost::result_of\<make\<Object\>(Expr, State, Data)\>::type</tt> typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; /// Let \c ax be <tt>when\<_, Ax\>()(e, s, d)</tt> /// for each \c x in <tt>[0,N]</tt>. /// Return <tt>result_type(a0, a1,... aN)</tt>. /// /// \param e The current expression /// \param s The current state /// \param d An arbitrary data BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { proto::detail::ignore_unused(e); proto::detail::ignore_unused(s); proto::detail::ignore_unused(d); return detail::construct<result_type>(BOOST_PP_ENUM(N, BOOST_PROTO_CONSTRUCT_ARG, DATA)); } }; }; #if N > 0 /// \brief A PrimitiveTransform which computes a type by evaluating any /// nested transforms and then constructs an object of that type with the /// current expression, state and data, transformed according /// to \c A0 through \c AN. template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct make<Object(BOOST_PP_ENUM_PARAMS(N, A)...)> : transform<make<Object(BOOST_PP_ENUM_PARAMS(N, A)...)> > { template<typename Expr, typename State, typename Data> struct impl : make< typename detail::expand_pattern< proto::arity_of<Expr>::value , BOOST_PP_CAT(A, BOOST_PP_DEC(N)) , detail::BOOST_PP_CAT(expand_pattern_rest_, BOOST_PP_DEC(N))< Object BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_DEC(N), A) > >::type >::template impl<Expr, State, Data> {}; }; #endif #undef N #endif PK �J�[cK`^� � transform/detail/lazy.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/transform/detail/preprocessed/lazy.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/lazy.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file lazy.hpp /// Contains definition of the lazy<> transform. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/lazy.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else #define N BOOST_PP_ITERATION() /// \brief A PrimitiveTransform that uses <tt>make\<\></tt> to build /// a CallableTransform, and then uses <tt>call\<\></tt> to apply it. /// /// <tt>lazy\<\></tt> is useful as a higher-order transform, when the /// transform to be applied depends on the current state of the /// transformation. The invocation of the <tt>make\<\></tt> transform /// evaluates any nested transforms, and the resulting type is treated /// as a CallableTransform, which is evaluated with <tt>call\<\></tt>. template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct lazy<Object(BOOST_PP_ENUM_PARAMS(N, A))> : transform<lazy<Object(BOOST_PP_ENUM_PARAMS(N, A))> > { template<typename Expr, typename State, typename Data> struct impl : call< typename make<Object>::template impl<Expr, State, Data>::result_type (BOOST_PP_ENUM_PARAMS(N, A)) >::template impl<Expr, State, Data> {}; }; #if N > 0 template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct lazy<Object(BOOST_PP_ENUM_PARAMS(N, A)...)> : transform<lazy<Object(BOOST_PP_ENUM_PARAMS(N, A)...)> > { template<typename Expr, typename State, typename Data> struct impl : lazy< typename detail::expand_pattern< proto::arity_of<Expr>::value , BOOST_PP_CAT(A, BOOST_PP_DEC(N)) , detail::BOOST_PP_CAT(expand_pattern_rest_, BOOST_PP_DEC(N))< Object BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_DEC(N), A) > >::type >::template impl<Expr, State, Data> {}; }; #endif #undef N #endif PK �J�[9�� � � transform/detail/when.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/transform/detail/preprocessed/when.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/when.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file when.hpp /// Definition of when transform. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/when.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else #define N BOOST_PP_ITERATION() /// \brief A grammar element and a PrimitiveTransform that associates /// a transform with the grammar. /// /// Use <tt>when\<\></tt> to override a grammar's default transform /// with a custom transform. It is for used when composing larger /// transforms by associating smaller transforms with individual /// rules in your grammar, as in the following transform which /// counts the number of terminals in an expression. /// /// \code /// // Count the terminals in an expression tree. /// // Must be invoked with initial state == mpl::int_<0>(). /// struct CountLeaves /// : or_< /// when<terminal<_>, mpl::next<_state>()> /// , otherwise<fold<_, _state, CountLeaves> > /// > /// {}; /// \endcode /// /// The <tt>when\<G, R(A0,A1,...)\></tt> form accepts either a /// CallableTransform or an ObjectTransform as its second parameter. /// <tt>when\<\></tt> uses <tt>is_callable\<R\>::value</tt> to /// distinguish between the two, and uses <tt>call\<\></tt> to /// evaluate CallableTransforms and <tt>make\<\></tt> to evaluate /// ObjectTransforms. template<typename Grammar, typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct when<Grammar, R(BOOST_PP_ENUM_PARAMS(N, A))> : detail::when_impl<Grammar, R, R(BOOST_PP_ENUM_PARAMS(N, A))> {}; #if N > 0 /// \brief A grammar element and a PrimitiveTransform that associates /// a transform with the grammar. /// /// Use <tt>when\<\></tt> to override a grammar's default transform /// with a custom transform. It is for used when composing larger /// transforms by associating smaller transforms with individual /// rules in your grammar, as in the following transform which /// counts the number of terminals in an expression. /// /// \code /// // Count the terminals in an expression tree. /// // Must be invoked with initial state == mpl::int_<0>(). /// struct CountLeaves /// : or_< /// when<terminal<_>, mpl::next<_state>()> /// , otherwise<fold<_, _state, CountLeaves> > /// > /// {}; /// \endcode /// /// The <tt>when\<G, R(A0,A1,...)\></tt> form accepts either a /// CallableTransform or an ObjectTransform as its second parameter. /// <tt>when\<\></tt> uses <tt>is_callable\<R\>::value</tt> to /// distinguish between the two, and uses <tt>call\<\></tt> to /// evaluate CallableTransforms and <tt>make\<\></tt> to evaluate /// ObjectTransforms. template<typename Grammar, typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct when<Grammar, R(BOOST_PP_ENUM_PARAMS(N, A)...)> : detail::when_impl<Grammar, R, R(BOOST_PP_ENUM_PARAMS(N, A)...)> {}; #endif #undef N #endif PK �J�[��Om� � * transform/detail/default_function_impl.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/transform/detail/preprocessed/default_function_impl.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_DEF_FUN_INVOKE_ARG(Z, M, DATA) \ BOOST_PROTO_DEFAULT_EVAL(Z, BOOST_PP_ADD(M, 2), DATA) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/default_function_impl.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file default_function_impl.hpp /// Contains definition of the default_function_impl, the implementation of the /// _default transform for function-like nodes. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (3, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/default_function_impl.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_DEF_FUN_INVOKE_ARG #else #define N BOOST_PP_ITERATION() template<typename Grammar, typename Expr, typename State, typename Data> struct default_function_impl<Grammar, Expr, State, Data, N> : transform_impl<Expr, State, Data> { BOOST_PP_REPEAT(N, BOOST_PROTO_DEFAULT_EVAL_TYPE, Expr) typedef typename proto::detail::result_of_fixup<r0>::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(BOOST_PP_ENUM_SHIFTED_PARAMS(N, r)) >::type result_type; result_type operator ()( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d ) const { return this->invoke(e, s, d, is_member_function_pointer<function_type>()); } private: result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::false_ ) const { return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)( BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL, e) ); } result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::true_ ) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (BOOST_PROTO_DEFAULT_EVAL(~, 1, e))) ->* BOOST_PROTO_DEFAULT_EVAL(~, 0, e) )(BOOST_PP_ENUM(BOOST_PP_SUB(N, 2), BOOST_PROTO_DEF_FUN_INVOKE_ARG, e)); } }; #undef N #endif PK �J�[�B�'! ! & transform/detail/pass_through_impl.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/transform/detail/preprocessed/pass_through_impl.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_DEFINE_TRANSFORM_TYPE(Z, N, DATA) \ typename Grammar::BOOST_PP_CAT(proto_child, N)::template impl< \ typename result_of::child_c<Expr, N>::type \ , State \ , Data \ >::result_type \ /**/ #define BOOST_PROTO_DEFINE_TRANSFORM(Z, N, DATA) \ typename Grammar::BOOST_PP_CAT(proto_child, N)::template impl< \ typename result_of::child_c<Expr, N>::type \ , State \ , Data \ >()( \ e.proto_base().BOOST_PP_CAT(child, N), s, d \ ) \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/pass_through_impl.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file pass_through_impl.hpp /// /// Specializations of pass_through_impl, used in the implementation of the /// pass_through transform. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/pass_through_impl.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_DEFINE_TRANSFORM #undef BOOST_PROTO_DEFINE_TRANSFORM_TYPE #else #define N BOOST_PP_ITERATION() template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> struct pass_through_impl<Grammar, Domain, Expr, State, Data, N> : transform_impl<Expr, State, Data> { typedef typename pass_through_impl::expr unref_expr; typedef typename mpl::if_c< is_same<Domain, deduce_domain>::value , typename unref_expr::proto_domain , Domain >::type result_domain; typedef typename base_expr< result_domain , typename unref_expr::proto_tag , BOOST_PP_CAT(list, N)< BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_TRANSFORM_TYPE, ~) > >::type expr_type; typedef typename result_domain::proto_generator proto_generator; typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) operator ()( typename pass_through_impl::expr_param e , typename pass_through_impl::state_param s , typename pass_through_impl::data_param d ) const { expr_type const that = { BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_TRANSFORM, ~) }; // Without this, MSVC complains that "that" is uninitialized, // and it actually triggers a runtime check in debug mode when // built with VC8. detail::ignore_unused(&that); return proto_generator()(that); } }; #undef N #endif PK �J�[KǀX�� �� & transform/detail/preprocessed/make.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file make.hpp /// Contains definition of the make<> transform. // // Copyright 2008 Eric Niebler. 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) namespace detail { template<typename R > struct is_applyable<R()> : mpl::true_ {}; template<typename R > struct is_applyable<R(*)()> : mpl::true_ {}; template<typename T, typename A> struct construct_<proto::expr<T, A, 0>, true> { typedef proto::expr<T, A, 0> result_type; template<typename A0> BOOST_FORCEINLINE result_type operator ()(A0 &a0) const { return result_type::make(a0); } }; template<typename T, typename A> struct construct_<proto::basic_expr<T, A, 0>, true> { typedef proto::basic_expr<T, A, 0> result_type; template<typename A0> BOOST_FORCEINLINE result_type operator ()(A0 &a0) const { return result_type::make(a0); } }; template<typename Type > BOOST_FORCEINLINE Type construct() { return construct_<Type>()(); } } template<typename Object > struct make<Object()> : transform<make<Object()> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { proto::detail::ignore_unused(e); proto::detail::ignore_unused(s); proto::detail::ignore_unused(d); return detail::construct<result_type>(); } }; }; namespace detail { template< template<typename> class R , typename A0 , typename Expr, typename State, typename Data > struct make_< R<A0> , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) > : nested_type_if< R<typename make_if_<A0, Expr, State, Data> ::type> , (make_if_<A0, Expr, State, Data> ::applied || false) > {}; template< template<typename> class R , typename A0 , typename Expr, typename State, typename Data > struct make_< noinvoke<R<A0> > , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) > { typedef R<typename make_if_<A0, Expr, State, Data> ::type> type; static bool const applied = true; }; template<typename R , typename A0> struct is_applyable<R(A0)> : mpl::true_ {}; template<typename R , typename A0> struct is_applyable<R(*)(A0)> : mpl::true_ {}; template<typename T, typename A> struct construct_<proto::expr<T, A, 1>, true> { typedef proto::expr<T, A, 1> result_type; template<typename A0> BOOST_FORCEINLINE result_type operator ()(A0 &a0) const { return result_type::make(a0); } }; template<typename T, typename A> struct construct_<proto::basic_expr<T, A, 1>, true> { typedef proto::basic_expr<T, A, 1> result_type; template<typename A0> BOOST_FORCEINLINE result_type operator ()(A0 &a0) const { return result_type::make(a0); } }; template<typename Type , typename A0> BOOST_FORCEINLINE Type construct(A0 &a0) { return construct_<Type>()(a0); } } template<typename Object , typename A0> struct make<Object(A0)> : transform<make<Object(A0)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { proto::detail::ignore_unused(e); proto::detail::ignore_unused(s); proto::detail::ignore_unused(d); return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) )); } }; }; template<typename Object , typename A0> struct make<Object(A0...)> : transform<make<Object(A0...)> > { template<typename Expr, typename State, typename Data> struct impl : make< typename detail::expand_pattern< proto::arity_of<Expr>::value , A0 , detail::expand_pattern_rest_0< Object > >::type >::template impl<Expr, State, Data> {}; }; namespace detail { template< template<typename , typename> class R , typename A0 , typename A1 , typename Expr, typename State, typename Data > struct make_< R<A0 , A1> , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(2) > : nested_type_if< R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type> , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || false) > {}; template< template<typename , typename> class R , typename A0 , typename A1 , typename Expr, typename State, typename Data > struct make_< noinvoke<R<A0 , A1> > , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) > { typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type> type; static bool const applied = true; }; template<typename R , typename A0 , typename A1> struct is_applyable<R(A0 , A1)> : mpl::true_ {}; template<typename R , typename A0 , typename A1> struct is_applyable<R(*)(A0 , A1)> : mpl::true_ {}; template<typename T, typename A> struct construct_<proto::expr<T, A, 2>, true> { typedef proto::expr<T, A, 2> result_type; template<typename A0 , typename A1> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1) const { return result_type::make(a0 , a1); } }; template<typename T, typename A> struct construct_<proto::basic_expr<T, A, 2>, true> { typedef proto::basic_expr<T, A, 2> result_type; template<typename A0 , typename A1> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1) const { return result_type::make(a0 , a1); } }; template<typename Type , typename A0 , typename A1> BOOST_FORCEINLINE Type construct(A0 &a0 , A1 &a1) { return construct_<Type>()(a0 , a1); } } template<typename Object , typename A0 , typename A1> struct make<Object(A0 , A1)> : transform<make<Object(A0 , A1)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { proto::detail::ignore_unused(e); proto::detail::ignore_unused(s); proto::detail::ignore_unused(d); return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) )); } }; }; template<typename Object , typename A0 , typename A1> struct make<Object(A0 , A1...)> : transform<make<Object(A0 , A1...)> > { template<typename Expr, typename State, typename Data> struct impl : make< typename detail::expand_pattern< proto::arity_of<Expr>::value , A1 , detail::expand_pattern_rest_1< Object , A0 > >::type >::template impl<Expr, State, Data> {}; }; namespace detail { template< template<typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename Expr, typename State, typename Data > struct make_< R<A0 , A1 , A2> , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(3) > : nested_type_if< R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type> , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || false) > {}; template< template<typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename Expr, typename State, typename Data > struct make_< noinvoke<R<A0 , A1 , A2> > , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) > { typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type> type; static bool const applied = true; }; template<typename R , typename A0 , typename A1 , typename A2> struct is_applyable<R(A0 , A1 , A2)> : mpl::true_ {}; template<typename R , typename A0 , typename A1 , typename A2> struct is_applyable<R(*)(A0 , A1 , A2)> : mpl::true_ {}; template<typename T, typename A> struct construct_<proto::expr<T, A, 3>, true> { typedef proto::expr<T, A, 3> result_type; template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const { return result_type::make(a0 , a1 , a2); } }; template<typename T, typename A> struct construct_<proto::basic_expr<T, A, 3>, true> { typedef proto::basic_expr<T, A, 3> result_type; template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const { return result_type::make(a0 , a1 , a2); } }; template<typename Type , typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE Type construct(A0 &a0 , A1 &a1 , A2 &a2) { return construct_<Type>()(a0 , a1 , a2); } } template<typename Object , typename A0 , typename A1 , typename A2> struct make<Object(A0 , A1 , A2)> : transform<make<Object(A0 , A1 , A2)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { proto::detail::ignore_unused(e); proto::detail::ignore_unused(s); proto::detail::ignore_unused(d); return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) )); } }; }; template<typename Object , typename A0 , typename A1 , typename A2> struct make<Object(A0 , A1 , A2...)> : transform<make<Object(A0 , A1 , A2...)> > { template<typename Expr, typename State, typename Data> struct impl : make< typename detail::expand_pattern< proto::arity_of<Expr>::value , A2 , detail::expand_pattern_rest_2< Object , A0 , A1 > >::type >::template impl<Expr, State, Data> {}; }; namespace detail { template< template<typename , typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename A3 , typename Expr, typename State, typename Data > struct make_< R<A0 , A1 , A2 , A3> , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(4) > : nested_type_if< R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type> , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || false) > {}; template< template<typename , typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename A3 , typename Expr, typename State, typename Data > struct make_< noinvoke<R<A0 , A1 , A2 , A3> > , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) > { typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type> type; static bool const applied = true; }; template<typename R , typename A0 , typename A1 , typename A2 , typename A3> struct is_applyable<R(A0 , A1 , A2 , A3)> : mpl::true_ {}; template<typename R , typename A0 , typename A1 , typename A2 , typename A3> struct is_applyable<R(*)(A0 , A1 , A2 , A3)> : mpl::true_ {}; template<typename T, typename A> struct construct_<proto::expr<T, A, 4>, true> { typedef proto::expr<T, A, 4> result_type; template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const { return result_type::make(a0 , a1 , a2 , a3); } }; template<typename T, typename A> struct construct_<proto::basic_expr<T, A, 4>, true> { typedef proto::basic_expr<T, A, 4> result_type; template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const { return result_type::make(a0 , a1 , a2 , a3); } }; template<typename Type , typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) { return construct_<Type>()(a0 , a1 , a2 , a3); } } template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> struct make<Object(A0 , A1 , A2 , A3)> : transform<make<Object(A0 , A1 , A2 , A3)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { proto::detail::ignore_unused(e); proto::detail::ignore_unused(s); proto::detail::ignore_unused(d); return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) )); } }; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> struct make<Object(A0 , A1 , A2 , A3...)> : transform<make<Object(A0 , A1 , A2 , A3...)> > { template<typename Expr, typename State, typename Data> struct impl : make< typename detail::expand_pattern< proto::arity_of<Expr>::value , A3 , detail::expand_pattern_rest_3< Object , A0 , A1 , A2 > >::type >::template impl<Expr, State, Data> {}; }; namespace detail { template< template<typename , typename , typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename Expr, typename State, typename Data > struct make_< R<A0 , A1 , A2 , A3 , A4> , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(5) > : nested_type_if< R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type> , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || false) > {}; template< template<typename , typename , typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename Expr, typename State, typename Data > struct make_< noinvoke<R<A0 , A1 , A2 , A3 , A4> > , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) > { typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type> type; static bool const applied = true; }; template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct is_applyable<R(A0 , A1 , A2 , A3 , A4)> : mpl::true_ {}; template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4)> : mpl::true_ {}; template<typename T, typename A> struct construct_<proto::expr<T, A, 5>, true> { typedef proto::expr<T, A, 5> result_type; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const { return result_type::make(a0 , a1 , a2 , a3 , a4); } }; template<typename T, typename A> struct construct_<proto::basic_expr<T, A, 5>, true> { typedef proto::basic_expr<T, A, 5> result_type; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const { return result_type::make(a0 , a1 , a2 , a3 , a4); } }; template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) { return construct_<Type>()(a0 , a1 , a2 , a3 , a4); } } template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct make<Object(A0 , A1 , A2 , A3 , A4)> : transform<make<Object(A0 , A1 , A2 , A3 , A4)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { proto::detail::ignore_unused(e); proto::detail::ignore_unused(s); proto::detail::ignore_unused(d); return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) )); } }; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct make<Object(A0 , A1 , A2 , A3 , A4...)> : transform<make<Object(A0 , A1 , A2 , A3 , A4...)> > { template<typename Expr, typename State, typename Data> struct impl : make< typename detail::expand_pattern< proto::arity_of<Expr>::value , A4 , detail::expand_pattern_rest_4< Object , A0 , A1 , A2 , A3 > >::type >::template impl<Expr, State, Data> {}; }; namespace detail { template< template<typename , typename , typename , typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename Expr, typename State, typename Data > struct make_< R<A0 , A1 , A2 , A3 , A4 , A5> , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(6) > : nested_type_if< R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type> , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || false) > {}; template< template<typename , typename , typename , typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename Expr, typename State, typename Data > struct make_< noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5> > , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) > { typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type> type; static bool const applied = true; }; template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5)> : mpl::true_ {}; template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5)> : mpl::true_ {}; template<typename T, typename A> struct construct_<proto::expr<T, A, 6>, true> { typedef proto::expr<T, A, 6> result_type; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const { return result_type::make(a0 , a1 , a2 , a3 , a4 , a5); } }; template<typename T, typename A> struct construct_<proto::basic_expr<T, A, 6>, true> { typedef proto::basic_expr<T, A, 6> result_type; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const { return result_type::make(a0 , a1 , a2 , a3 , a4 , a5); } }; template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) { return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5); } } template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct make<Object(A0 , A1 , A2 , A3 , A4 , A5)> : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { proto::detail::ignore_unused(e); proto::detail::ignore_unused(s); proto::detail::ignore_unused(d); return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) )); } }; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct make<Object(A0 , A1 , A2 , A3 , A4 , A5...)> : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5...)> > { template<typename Expr, typename State, typename Data> struct impl : make< typename detail::expand_pattern< proto::arity_of<Expr>::value , A5 , detail::expand_pattern_rest_5< Object , A0 , A1 , A2 , A3 , A4 > >::type >::template impl<Expr, State, Data> {}; }; namespace detail { template< template<typename , typename , typename , typename , typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename Expr, typename State, typename Data > struct make_< R<A0 , A1 , A2 , A3 , A4 , A5 , A6> , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(7) > : nested_type_if< R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type> , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || false) > {}; template< template<typename , typename , typename , typename , typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename Expr, typename State, typename Data > struct make_< noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6> > , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) > { typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type> type; static bool const applied = true; }; template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : mpl::true_ {}; template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : mpl::true_ {}; template<typename T, typename A> struct construct_<proto::expr<T, A, 7>, true> { typedef proto::expr<T, A, 7> result_type; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const { return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6); } }; template<typename T, typename A> struct construct_<proto::basic_expr<T, A, 7>, true> { typedef proto::basic_expr<T, A, 7> result_type; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const { return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6); } }; template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) { return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6); } } template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { proto::detail::ignore_unused(e); proto::detail::ignore_unused(s); proto::detail::ignore_unused(d); return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) )); } }; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> > { template<typename Expr, typename State, typename Data> struct impl : make< typename detail::expand_pattern< proto::arity_of<Expr>::value , A6 , detail::expand_pattern_rest_6< Object , A0 , A1 , A2 , A3 , A4 , A5 > >::type >::template impl<Expr, State, Data> {}; }; namespace detail { template< template<typename , typename , typename , typename , typename , typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename Expr, typename State, typename Data > struct make_< R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(8) > : nested_type_if< R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type> , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || false) > {}; template< template<typename , typename , typename , typename , typename , typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename Expr, typename State, typename Data > struct make_< noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> > , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) > { typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type> type; static bool const applied = true; }; template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : mpl::true_ {}; template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : mpl::true_ {}; template<typename T, typename A> struct construct_<proto::expr<T, A, 8>, true> { typedef proto::expr<T, A, 8> result_type; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const { return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } }; template<typename T, typename A> struct construct_<proto::basic_expr<T, A, 8>, true> { typedef proto::basic_expr<T, A, 8> result_type; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const { return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } }; template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) { return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } } template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { proto::detail::ignore_unused(e); proto::detail::ignore_unused(s); proto::detail::ignore_unused(d); return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) )); } }; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> > { template<typename Expr, typename State, typename Data> struct impl : make< typename detail::expand_pattern< proto::arity_of<Expr>::value , A7 , detail::expand_pattern_rest_7< Object , A0 , A1 , A2 , A3 , A4 , A5 , A6 > >::type >::template impl<Expr, State, Data> {}; }; namespace detail { template< template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename Expr, typename State, typename Data > struct make_< R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(9) > : nested_type_if< R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type> , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || make_if_<A8, Expr, State, Data> ::applied || false) > {}; template< template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename Expr, typename State, typename Data > struct make_< noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> > , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) > { typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type> type; static bool const applied = true; }; template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : mpl::true_ {}; template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : mpl::true_ {}; template<typename T, typename A> struct construct_<proto::expr<T, A, 9>, true> { typedef proto::expr<T, A, 9> result_type; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const { return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } }; template<typename T, typename A> struct construct_<proto::basic_expr<T, A, 9>, true> { typedef proto::basic_expr<T, A, 9> result_type; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const { return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } }; template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) { return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } } template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { proto::detail::ignore_unused(e); proto::detail::ignore_unused(s); proto::detail::ignore_unused(d); return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) )); } }; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> > { template<typename Expr, typename State, typename Data> struct impl : make< typename detail::expand_pattern< proto::arity_of<Expr>::value , A8 , detail::expand_pattern_rest_8< Object , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 > >::type >::template impl<Expr, State, Data> {}; }; namespace detail { template< template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename Expr, typename State, typename Data > struct make_< R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(10) > : nested_type_if< R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type , typename make_if_<A9, Expr, State, Data> ::type> , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || make_if_<A8, Expr, State, Data> ::applied || make_if_<A9, Expr, State, Data> ::applied || false) > {}; template< template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename Expr, typename State, typename Data > struct make_< noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> > , Expr, State, Data BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) > { typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type , typename make_if_<A9, Expr, State, Data> ::type> type; static bool const applied = true; }; template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : mpl::true_ {}; template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : mpl::true_ {}; template<typename T, typename A> struct construct_<proto::expr<T, A, 10>, true> { typedef proto::expr<T, A, 10> result_type; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const { return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); } }; template<typename T, typename A> struct construct_<proto::basic_expr<T, A, 10>, true> { typedef proto::basic_expr<T, A, 10> result_type; template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> BOOST_FORCEINLINE result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const { return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); } }; template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> BOOST_FORCEINLINE Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) { return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); } } template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { proto::detail::ignore_unused(e); proto::detail::ignore_unused(s); proto::detail::ignore_unused(d); return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) )); } }; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> > { template<typename Expr, typename State, typename Data> struct impl : make< typename detail::expand_pattern< proto::arity_of<Expr>::value , A9 , detail::expand_pattern_rest_9< Object , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 > >::type >::template impl<Expr, State, Data> {}; }; PK �J�[5�)�3 �3 & transform/detail/preprocessed/lazy.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file lazy.hpp /// Contains definition of the lazy<> transform. // // Copyright 2008 Eric Niebler. 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) template<typename Object > struct lazy<Object()> : transform<lazy<Object()> > { template<typename Expr, typename State, typename Data> struct impl : call< typename make<Object>::template impl<Expr, State, Data>::result_type () >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0> struct lazy<Object(A0)> : transform<lazy<Object(A0)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename make<Object>::template impl<Expr, State, Data>::result_type (A0) >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0> struct lazy<Object(A0...)> : transform<lazy<Object(A0...)> > { template<typename Expr, typename State, typename Data> struct impl : lazy< typename detail::expand_pattern< proto::arity_of<Expr>::value , A0 , detail::expand_pattern_rest_0< Object > >::type >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1> struct lazy<Object(A0 , A1)> : transform<lazy<Object(A0 , A1)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename make<Object>::template impl<Expr, State, Data>::result_type (A0 , A1) >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1> struct lazy<Object(A0 , A1...)> : transform<lazy<Object(A0 , A1...)> > { template<typename Expr, typename State, typename Data> struct impl : lazy< typename detail::expand_pattern< proto::arity_of<Expr>::value , A1 , detail::expand_pattern_rest_1< Object , A0 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2> struct lazy<Object(A0 , A1 , A2)> : transform<lazy<Object(A0 , A1 , A2)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename make<Object>::template impl<Expr, State, Data>::result_type (A0 , A1 , A2) >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2> struct lazy<Object(A0 , A1 , A2...)> : transform<lazy<Object(A0 , A1 , A2...)> > { template<typename Expr, typename State, typename Data> struct impl : lazy< typename detail::expand_pattern< proto::arity_of<Expr>::value , A2 , detail::expand_pattern_rest_2< Object , A0 , A1 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> struct lazy<Object(A0 , A1 , A2 , A3)> : transform<lazy<Object(A0 , A1 , A2 , A3)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename make<Object>::template impl<Expr, State, Data>::result_type (A0 , A1 , A2 , A3) >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> struct lazy<Object(A0 , A1 , A2 , A3...)> : transform<lazy<Object(A0 , A1 , A2 , A3...)> > { template<typename Expr, typename State, typename Data> struct impl : lazy< typename detail::expand_pattern< proto::arity_of<Expr>::value , A3 , detail::expand_pattern_rest_3< Object , A0 , A1 , A2 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct lazy<Object(A0 , A1 , A2 , A3 , A4)> : transform<lazy<Object(A0 , A1 , A2 , A3 , A4)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename make<Object>::template impl<Expr, State, Data>::result_type (A0 , A1 , A2 , A3 , A4) >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct lazy<Object(A0 , A1 , A2 , A3 , A4...)> : transform<lazy<Object(A0 , A1 , A2 , A3 , A4...)> > { template<typename Expr, typename State, typename Data> struct impl : lazy< typename detail::expand_pattern< proto::arity_of<Expr>::value , A4 , detail::expand_pattern_rest_4< Object , A0 , A1 , A2 , A3 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)> : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename make<Object>::template impl<Expr, State, Data>::result_type (A0 , A1 , A2 , A3 , A4 , A5) >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)> : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)> > { template<typename Expr, typename State, typename Data> struct impl : lazy< typename detail::expand_pattern< proto::arity_of<Expr>::value , A5 , detail::expand_pattern_rest_5< Object , A0 , A1 , A2 , A3 , A4 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename make<Object>::template impl<Expr, State, Data>::result_type (A0 , A1 , A2 , A3 , A4 , A5 , A6) >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> > { template<typename Expr, typename State, typename Data> struct impl : lazy< typename detail::expand_pattern< proto::arity_of<Expr>::value , A6 , detail::expand_pattern_rest_6< Object , A0 , A1 , A2 , A3 , A4 , A5 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename make<Object>::template impl<Expr, State, Data>::result_type (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> > { template<typename Expr, typename State, typename Data> struct impl : lazy< typename detail::expand_pattern< proto::arity_of<Expr>::value , A7 , detail::expand_pattern_rest_7< Object , A0 , A1 , A2 , A3 , A4 , A5 , A6 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename make<Object>::template impl<Expr, State, Data>::result_type (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> > { template<typename Expr, typename State, typename Data> struct impl : lazy< typename detail::expand_pattern< proto::arity_of<Expr>::value , A8 , detail::expand_pattern_rest_8< Object , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename make<Object>::template impl<Expr, State, Data>::result_type (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) >::template impl<Expr, State, Data> {}; }; template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> > { template<typename Expr, typename State, typename Data> struct impl : lazy< typename detail::expand_pattern< proto::arity_of<Expr>::value , A9 , detail::expand_pattern_rest_9< Object , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 > >::type >::template impl<Expr, State, Data> {}; }; PK �J�[T�d�K K & transform/detail/preprocessed/when.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file when.hpp /// Definition of when transform. // // Copyright 2008 Eric Niebler. 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) template<typename Grammar, typename R > struct when<Grammar, R()> : detail::when_impl<Grammar, R, R()> {}; template<typename Grammar, typename R , typename A0> struct when<Grammar, R(A0)> : detail::when_impl<Grammar, R, R(A0)> {}; template<typename Grammar, typename R , typename A0> struct when<Grammar, R(A0...)> : detail::when_impl<Grammar, R, R(A0...)> {}; template<typename Grammar, typename R , typename A0 , typename A1> struct when<Grammar, R(A0 , A1)> : detail::when_impl<Grammar, R, R(A0 , A1)> {}; template<typename Grammar, typename R , typename A0 , typename A1> struct when<Grammar, R(A0 , A1...)> : detail::when_impl<Grammar, R, R(A0 , A1...)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2> struct when<Grammar, R(A0 , A1 , A2)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2> struct when<Grammar, R(A0 , A1 , A2...)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2...)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3> struct when<Grammar, R(A0 , A1 , A2 , A3)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3> struct when<Grammar, R(A0 , A1 , A2 , A3...)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3...)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct when<Grammar, R(A0 , A1 , A2 , A3 , A4)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct when<Grammar, R(A0 , A1 , A2 , A3 , A4...)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4...)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5...)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5...)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> {}; template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> {}; PK �J�[Q=�s@q @q 7 transform/detail/preprocessed/default_function_impl.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file default_function_impl.hpp /// Contains definition of the default_function_impl, the implementation of the /// _default transform for function-like nodes. // // Copyright 2008 Eric Niebler. 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) template<typename Grammar, typename Expr, typename State, typename Data> struct default_function_impl<Grammar, Expr, State, Data, 3> : transform_impl<Expr, State, Data> { typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename proto::detail::result_of_fixup<r0>::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(r1 , r2) >::type result_type; result_type operator ()( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d ) const { return this->invoke(e, s, d, is_member_function_pointer<function_type>()); } private: result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::false_ ) const { return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) ); } result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::true_ ) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d )); } }; template<typename Grammar, typename Expr, typename State, typename Data> struct default_function_impl<Grammar, Expr, State, Data, 4> : transform_impl<Expr, State, Data> { typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename proto::detail::result_of_fixup<r0>::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(r1 , r2 , r3) >::type result_type; result_type operator ()( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d ) const { return this->invoke(e, s, d, is_member_function_pointer<function_type>()); } private: result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::false_ ) const { return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) ); } result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::true_ ) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d )); } }; template<typename Grammar, typename Expr, typename State, typename Data> struct default_function_impl<Grammar, Expr, State, Data, 5> : transform_impl<Expr, State, Data> { typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename proto::detail::result_of_fixup<r0>::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(r1 , r2 , r3 , r4) >::type result_type; result_type operator ()( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d ) const { return this->invoke(e, s, d, is_member_function_pointer<function_type>()); } private: result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::false_ ) const { return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) ); } result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::true_ ) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d )); } }; template<typename Grammar, typename Expr, typename State, typename Data> struct default_function_impl<Grammar, Expr, State, Data, 6> : transform_impl<Expr, State, Data> { typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename proto::detail::result_of_fixup<r0>::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(r1 , r2 , r3 , r4 , r5) >::type result_type; result_type operator ()( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d ) const { return this->invoke(e, s, d, is_member_function_pointer<function_type>()); } private: result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::false_ ) const { return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) ); } result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::true_ ) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d )); } }; template<typename Grammar, typename Expr, typename State, typename Data> struct default_function_impl<Grammar, Expr, State, Data, 7> : transform_impl<Expr, State, Data> { typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename proto::detail::result_of_fixup<r0>::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(r1 , r2 , r3 , r4 , r5 , r6) >::type result_type; result_type operator ()( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d ) const { return this->invoke(e, s, d, is_member_function_pointer<function_type>()); } private: result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::false_ ) const { return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) ); } result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::true_ ) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d )); } }; template<typename Grammar, typename Expr, typename State, typename Data> struct default_function_impl<Grammar, Expr, State, Data, 8> : transform_impl<Expr, State, Data> { typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7; typedef typename proto::detail::result_of_fixup<r0>::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7) >::type result_type; result_type operator ()( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d ) const { return this->invoke(e, s, d, is_member_function_pointer<function_type>()); } private: result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::false_ ) const { return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) ); } result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::true_ ) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d )); } }; template<typename Grammar, typename Expr, typename State, typename Data> struct default_function_impl<Grammar, Expr, State, Data, 9> : transform_impl<Expr, State, Data> { typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7; typedef typename result_of::child_c< Expr, 8>::type e8; typedef typename Grammar::template impl<e8, State, Data>::result_type r8; typedef typename proto::detail::result_of_fixup<r0>::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7 , r8) >::type result_type; result_type operator ()( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d ) const { return this->invoke(e, s, d, is_member_function_pointer<function_type>()); } private: result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::false_ ) const { return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) ); } result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::true_ ) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d )); } }; template<typename Grammar, typename Expr, typename State, typename Data> struct default_function_impl<Grammar, Expr, State, Data, 10> : transform_impl<Expr, State, Data> { typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7; typedef typename result_of::child_c< Expr, 8>::type e8; typedef typename Grammar::template impl<e8, State, Data>::result_type r8; typedef typename result_of::child_c< Expr, 9>::type e9; typedef typename Grammar::template impl<e9, State, Data>::result_type r9; typedef typename proto::detail::result_of_fixup<r0>::type function_type; typedef typename BOOST_PROTO_RESULT_OF< function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7 , r8 , r9) >::type result_type; result_type operator ()( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d ) const { return this->invoke(e, s, d, is_member_function_pointer<function_type>()); } private: result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::false_ ) const { return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) , typename Grammar::template impl<e9, State, Data>()( proto::child_c< 9>( e), s, d ) ); } result_type invoke( typename default_function_impl::expr_param e , typename default_function_impl::state_param s , typename default_function_impl::data_param d , mpl::true_ ) const { BOOST_PROTO_USE_GET_POINTER(); typedef typename detail::class_member_traits<function_type>::class_type class_type; return ( BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) , typename Grammar::template impl<e9, State, Data>()( proto::child_c< 9>( e), s, d )); } }; PK �J�[��k� q q 3 transform/detail/preprocessed/pass_through_impl.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file pass_through_impl.hpp /// /// Specializations of pass_through_impl, used in the implementation of the /// pass_through transform. // // Copyright 2008 Eric Niebler. 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) template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> struct pass_through_impl<Grammar, Domain, Expr, State, Data, 1> : transform_impl<Expr, State, Data> { typedef typename pass_through_impl::expr unref_expr; typedef typename mpl::if_c< is_same<Domain, deduce_domain>::value , typename unref_expr::proto_domain , Domain >::type result_domain; typedef typename base_expr< result_domain , typename unref_expr::proto_tag , list1< typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type > >::type expr_type; typedef typename result_domain::proto_generator proto_generator; typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) operator ()( typename pass_through_impl::expr_param e , typename pass_through_impl::state_param s , typename pass_through_impl::data_param d ) const { expr_type const that = { typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) }; detail::ignore_unused(&that); return proto_generator()(that); } }; template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> struct pass_through_impl<Grammar, Domain, Expr, State, Data, 2> : transform_impl<Expr, State, Data> { typedef typename pass_through_impl::expr unref_expr; typedef typename mpl::if_c< is_same<Domain, deduce_domain>::value , typename unref_expr::proto_domain , Domain >::type result_domain; typedef typename base_expr< result_domain , typename unref_expr::proto_tag , list2< typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type > >::type expr_type; typedef typename result_domain::proto_generator proto_generator; typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) operator ()( typename pass_through_impl::expr_param e , typename pass_through_impl::state_param s , typename pass_through_impl::data_param d ) const { expr_type const that = { typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) }; detail::ignore_unused(&that); return proto_generator()(that); } }; template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> struct pass_through_impl<Grammar, Domain, Expr, State, Data, 3> : transform_impl<Expr, State, Data> { typedef typename pass_through_impl::expr unref_expr; typedef typename mpl::if_c< is_same<Domain, deduce_domain>::value , typename unref_expr::proto_domain , Domain >::type result_domain; typedef typename base_expr< result_domain , typename unref_expr::proto_tag , list3< typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type > >::type expr_type; typedef typename result_domain::proto_generator proto_generator; typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) operator ()( typename pass_through_impl::expr_param e , typename pass_through_impl::state_param s , typename pass_through_impl::data_param d ) const { expr_type const that = { typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) }; detail::ignore_unused(&that); return proto_generator()(that); } }; template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> struct pass_through_impl<Grammar, Domain, Expr, State, Data, 4> : transform_impl<Expr, State, Data> { typedef typename pass_through_impl::expr unref_expr; typedef typename mpl::if_c< is_same<Domain, deduce_domain>::value , typename unref_expr::proto_domain , Domain >::type result_domain; typedef typename base_expr< result_domain , typename unref_expr::proto_tag , list4< typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type > >::type expr_type; typedef typename result_domain::proto_generator proto_generator; typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) operator ()( typename pass_through_impl::expr_param e , typename pass_through_impl::state_param s , typename pass_through_impl::data_param d ) const { expr_type const that = { typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) }; detail::ignore_unused(&that); return proto_generator()(that); } }; template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> struct pass_through_impl<Grammar, Domain, Expr, State, Data, 5> : transform_impl<Expr, State, Data> { typedef typename pass_through_impl::expr unref_expr; typedef typename mpl::if_c< is_same<Domain, deduce_domain>::value , typename unref_expr::proto_domain , Domain >::type result_domain; typedef typename base_expr< result_domain , typename unref_expr::proto_tag , list5< typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type > >::type expr_type; typedef typename result_domain::proto_generator proto_generator; typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) operator ()( typename pass_through_impl::expr_param e , typename pass_through_impl::state_param s , typename pass_through_impl::data_param d ) const { expr_type const that = { typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) }; detail::ignore_unused(&that); return proto_generator()(that); } }; template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> struct pass_through_impl<Grammar, Domain, Expr, State, Data, 6> : transform_impl<Expr, State, Data> { typedef typename pass_through_impl::expr unref_expr; typedef typename mpl::if_c< is_same<Domain, deduce_domain>::value , typename unref_expr::proto_domain , Domain >::type result_domain; typedef typename base_expr< result_domain , typename unref_expr::proto_tag , list6< typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type > >::type expr_type; typedef typename result_domain::proto_generator proto_generator; typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) operator ()( typename pass_through_impl::expr_param e , typename pass_through_impl::state_param s , typename pass_through_impl::data_param d ) const { expr_type const that = { typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) }; detail::ignore_unused(&that); return proto_generator()(that); } }; template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> struct pass_through_impl<Grammar, Domain, Expr, State, Data, 7> : transform_impl<Expr, State, Data> { typedef typename pass_through_impl::expr unref_expr; typedef typename mpl::if_c< is_same<Domain, deduce_domain>::value , typename unref_expr::proto_domain , Domain >::type result_domain; typedef typename base_expr< result_domain , typename unref_expr::proto_tag , list7< typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type > >::type expr_type; typedef typename result_domain::proto_generator proto_generator; typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) operator ()( typename pass_through_impl::expr_param e , typename pass_through_impl::state_param s , typename pass_through_impl::data_param d ) const { expr_type const that = { typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) }; detail::ignore_unused(&that); return proto_generator()(that); } }; template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> struct pass_through_impl<Grammar, Domain, Expr, State, Data, 8> : transform_impl<Expr, State, Data> { typedef typename pass_through_impl::expr unref_expr; typedef typename mpl::if_c< is_same<Domain, deduce_domain>::value , typename unref_expr::proto_domain , Domain >::type result_domain; typedef typename base_expr< result_domain , typename unref_expr::proto_tag , list8< typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type > >::type expr_type; typedef typename result_domain::proto_generator proto_generator; typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) operator ()( typename pass_through_impl::expr_param e , typename pass_through_impl::state_param s , typename pass_through_impl::data_param d ) const { expr_type const that = { typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d ) }; detail::ignore_unused(&that); return proto_generator()(that); } }; template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> struct pass_through_impl<Grammar, Domain, Expr, State, Data, 9> : transform_impl<Expr, State, Data> { typedef typename pass_through_impl::expr unref_expr; typedef typename mpl::if_c< is_same<Domain, deduce_domain>::value , typename unref_expr::proto_domain , Domain >::type result_domain; typedef typename base_expr< result_domain , typename unref_expr::proto_tag , list9< typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >::result_type > >::type expr_type; typedef typename result_domain::proto_generator proto_generator; typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) operator ()( typename pass_through_impl::expr_param e , typename pass_through_impl::state_param s , typename pass_through_impl::data_param d ) const { expr_type const that = { typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d ) , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >()( e.proto_base().child8, s, d ) }; detail::ignore_unused(&that); return proto_generator()(that); } }; template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> struct pass_through_impl<Grammar, Domain, Expr, State, Data, 10> : transform_impl<Expr, State, Data> { typedef typename pass_through_impl::expr unref_expr; typedef typename mpl::if_c< is_same<Domain, deduce_domain>::value , typename unref_expr::proto_domain , Domain >::type result_domain; typedef typename base_expr< result_domain , typename unref_expr::proto_tag , list10< typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >::result_type , typename Grammar::proto_child9::template impl< typename result_of::child_c<Expr, 9>::type , State , Data >::result_type > >::type expr_type; typedef typename result_domain::proto_generator proto_generator; typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) operator ()( typename pass_through_impl::expr_param e , typename pass_through_impl::state_param s , typename pass_through_impl::data_param d ) const { expr_type const that = { typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d ) , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >()( e.proto_base().child8, s, d ) , typename Grammar::proto_child9::template impl< typename result_of::child_c<Expr, 9>::type , State , Data >()( e.proto_base().child9, s, d ) }; detail::ignore_unused(&that); return proto_generator()(that); } }; PK �J�[��N�] ] + transform/detail/preprocessed/pack_impl.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file pack_impl.hpp /// Contains helpers for pseudo-pack expansion. // // Copyright 2012 Eric Niebler. 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) template<typename Fun, typename Cont> struct expand_pattern<1, Fun, Cont> : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type> { BOOST_MPL_ASSERT_MSG( (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN , (Fun) ); }; template<typename Ret > struct expand_pattern_rest_0 { template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void , typename C8 = void , typename C9 = void , typename C10 = void> struct cat; template<typename C0> struct cat<C0> { typedef msvc_fun_workaround<Ret( C0)> type; }; template<typename C0 , typename C1> struct cat<C0 , C1> { typedef msvc_fun_workaround<Ret( C0 , C1)> type; }; template<typename C0 , typename C1 , typename C2> struct cat<C0 , C1 , C2> { typedef msvc_fun_workaround<Ret( C0 , C1 , C2)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3> struct cat<C0 , C1 , C2 , C3> { typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> struct cat<C0 , C1 , C2 , C3 , C4> { typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> struct cat<C0 , C1 , C2 , C3 , C4 , C5> { typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> { typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7> struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7> { typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8> struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8> { typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8 , typename C9> struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8 , C9> { typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8 , C9)> type; }; }; template<typename Fun, typename Cont> struct expand_pattern<2, Fun, Cont> : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type> { BOOST_MPL_ASSERT_MSG( (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN , (Fun) ); }; template<typename Ret , typename A0> struct expand_pattern_rest_1 { template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void , typename C8 = void , typename C9 = void> struct cat; template<typename C0> struct cat<C0> { typedef msvc_fun_workaround<Ret(A0 , C0)> type; }; template<typename C0 , typename C1> struct cat<C0 , C1> { typedef msvc_fun_workaround<Ret(A0 , C0 , C1)> type; }; template<typename C0 , typename C1 , typename C2> struct cat<C0 , C1 , C2> { typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3> struct cat<C0 , C1 , C2 , C3> { typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> struct cat<C0 , C1 , C2 , C3 , C4> { typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> struct cat<C0 , C1 , C2 , C3 , C4 , C5> { typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> { typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7> struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7> { typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8> struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8> { typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8)> type; }; }; template<typename Fun, typename Cont> struct expand_pattern<3, Fun, Cont> : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type> { BOOST_MPL_ASSERT_MSG( (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN , (Fun) ); }; template<typename Ret , typename A0 , typename A1> struct expand_pattern_rest_2 { template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void , typename C8 = void> struct cat; template<typename C0> struct cat<C0> { typedef msvc_fun_workaround<Ret(A0 , A1 , C0)> type; }; template<typename C0 , typename C1> struct cat<C0 , C1> { typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1)> type; }; template<typename C0 , typename C1 , typename C2> struct cat<C0 , C1 , C2> { typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3> struct cat<C0 , C1 , C2 , C3> { typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> struct cat<C0 , C1 , C2 , C3 , C4> { typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> struct cat<C0 , C1 , C2 , C3 , C4 , C5> { typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> { typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7> struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7> { typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type; }; }; template<typename Fun, typename Cont> struct expand_pattern<4, Fun, Cont> : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type> { BOOST_MPL_ASSERT_MSG( (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN , (Fun) ); }; template<typename Ret , typename A0 , typename A1 , typename A2> struct expand_pattern_rest_3 { template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void> struct cat; template<typename C0> struct cat<C0> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0)> type; }; template<typename C0 , typename C1> struct cat<C0 , C1> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1)> type; }; template<typename C0 , typename C1 , typename C2> struct cat<C0 , C1 , C2> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3> struct cat<C0 , C1 , C2 , C3> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> struct cat<C0 , C1 , C2 , C3 , C4> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> struct cat<C0 , C1 , C2 , C3 , C4 , C5> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4 , C5)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; }; }; template<typename Fun, typename Cont> struct expand_pattern<5, Fun, Cont> : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type> { BOOST_MPL_ASSERT_MSG( (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN , (Fun) ); }; template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3> struct expand_pattern_rest_4 { template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void> struct cat; template<typename C0> struct cat<C0> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0)> type; }; template<typename C0 , typename C1> struct cat<C0 , C1> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1)> type; }; template<typename C0 , typename C1 , typename C2> struct cat<C0 , C1 , C2> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3> struct cat<C0 , C1 , C2 , C3> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> struct cat<C0 , C1 , C2 , C3 , C4> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3 , C4)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> struct cat<C0 , C1 , C2 , C3 , C4 , C5> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3 , C4 , C5)> type; }; }; template<typename Fun, typename Cont> struct expand_pattern<6, Fun, Cont> : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type> { BOOST_MPL_ASSERT_MSG( (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN , (Fun) ); }; template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct expand_pattern_rest_5 { template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void> struct cat; template<typename C0> struct cat<C0> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0)> type; }; template<typename C0 , typename C1> struct cat<C0 , C1> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1)> type; }; template<typename C0 , typename C1 , typename C2> struct cat<C0 , C1 , C2> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3> struct cat<C0 , C1 , C2 , C3> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2 , C3)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> struct cat<C0 , C1 , C2 , C3 , C4> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2 , C3 , C4)> type; }; }; template<typename Fun, typename Cont> struct expand_pattern<7, Fun, Cont> : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type> { BOOST_MPL_ASSERT_MSG( (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN , (Fun) ); }; template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct expand_pattern_rest_6 { template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void> struct cat; template<typename C0> struct cat<C0> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0)> type; }; template<typename C0 , typename C1> struct cat<C0 , C1> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1)> type; }; template<typename C0 , typename C1 , typename C2> struct cat<C0 , C1 , C2> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1 , C2)> type; }; template<typename C0 , typename C1 , typename C2 , typename C3> struct cat<C0 , C1 , C2 , C3> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1 , C2 , C3)> type; }; }; template<typename Fun, typename Cont> struct expand_pattern<8, Fun, Cont> : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type> { BOOST_MPL_ASSERT_MSG( (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN , (Fun) ); }; template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct expand_pattern_rest_7 { template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void> struct cat; template<typename C0> struct cat<C0> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0)> type; }; template<typename C0 , typename C1> struct cat<C0 , C1> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0 , C1)> type; }; template<typename C0 , typename C1 , typename C2> struct cat<C0 , C1 , C2> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0 , C1 , C2)> type; }; }; template<typename Fun, typename Cont> struct expand_pattern<9, Fun, Cont> : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 8>, Fun>::type> { BOOST_MPL_ASSERT_MSG( (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN , (Fun) ); }; template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct expand_pattern_rest_8 { template<typename C0 = void , typename C1 = void , typename C2 = void> struct cat; template<typename C0> struct cat<C0> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , C0)> type; }; template<typename C0 , typename C1> struct cat<C0 , C1> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , C0 , C1)> type; }; }; template<typename Fun, typename Cont> struct expand_pattern<10, Fun, Cont> : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 8>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 9>, Fun>::type> { BOOST_MPL_ASSERT_MSG( (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN , (Fun) ); }; template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct expand_pattern_rest_9 { template<typename C0 = void , typename C1 = void> struct cat; template<typename C0> struct cat<C0> { typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , C0)> type; }; }; PK �J�[��ٵ 1 transform/detail/preprocessed/construct_funop.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file construct_funop.hpp /// Overloads of construct_\<\>::operator(). // // Copyright 2008 Eric Niebler. 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) template<typename A0> BOOST_FORCEINLINE Type operator ()(A0 &a0) const { return Type(a0); } template<typename A0 , typename A1> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1) const { return Type(a0 , a1); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const { return Type(a0 , a1 , a2); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const { return Type(a0 , a1 , a2 , a3); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const { return Type(a0 , a1 , a2 , a3 , a4); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const { return Type(a0 , a1 , a2 , a3 , a4 , a5); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const { return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const { return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const { return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const { return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); } PK �J�[�� #�" �" - transform/detail/preprocessed/expand_pack.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file expand_pack.hpp /// Contains helpers for pseudo-pack expansion. // // Copyright 2012 Eric Niebler. 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) template<typename Tfx, typename Ret > struct expand_pattern_helper<Tfx, Ret()> { typedef Ret (*type)(); typedef mpl::bool_< false> applied; }; template<typename Tfx, typename Ret , typename A0> struct expand_pattern_helper<Tfx, Ret(A0)> { typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type); typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || false> applied; }; template<typename Tfx, typename Ret , typename A0 , typename A1> struct expand_pattern_helper<Tfx, Ret(A0 , A1)> { typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type); typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || false> applied; }; template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2> struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2)> { typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type); typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || false> applied; }; template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3> struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3)> { typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type); typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || false> applied; }; template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4)> { typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type); typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || false> applied; }; template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5)> { typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type); typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || false> applied; }; template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6)> { typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type); typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || false> applied; }; template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> { typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type , typename expand_pattern_helper<Tfx, A7>::type); typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || expand_pattern_helper<Tfx, A7>::applied::value || false> applied; }; template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> { typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type , typename expand_pattern_helper<Tfx, A7>::type , typename expand_pattern_helper<Tfx, A8>::type); typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || expand_pattern_helper<Tfx, A7>::applied::value || expand_pattern_helper<Tfx, A8>::applied::value || false> applied; }; template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> { typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type , typename expand_pattern_helper<Tfx, A7>::type , typename expand_pattern_helper<Tfx, A8>::type , typename expand_pattern_helper<Tfx, A9>::type); typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || expand_pattern_helper<Tfx, A7>::applied::value || expand_pattern_helper<Tfx, A8>::applied::value || expand_pattern_helper<Tfx, A9>::applied::value || false> applied; }; PK �J�[��p�� �� + transform/detail/preprocessed/fold_impl.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file fold_impl.hpp /// Contains definition of fold_impl<> and reverse_fold_impl<> templates. // // Copyright 2008 Eric Niebler. 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) template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct fold_impl<State0, Fun, Expr, State, Data, 1> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef state1 result_type; result_type operator ()( typename fold_impl::expr_param e , typename fold_impl::state_param s , typename fold_impl::data_param d ) const { state0 s0 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); return s1; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct reverse_fold_impl<State0, Fun, Expr, State, Data, 1> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; typedef state0 result_type; result_type operator ()( typename reverse_fold_impl::expr_param e , typename reverse_fold_impl::state_param s , typename reverse_fold_impl::data_param d ) const { state1 s1 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); return s0; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct fold_impl<State0, Fun, Expr, State, Data, 2> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef state2 result_type; result_type operator ()( typename fold_impl::expr_param e , typename fold_impl::state_param s , typename fold_impl::data_param d ) const { state0 s0 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); return s2; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct reverse_fold_impl<State0, Fun, Expr, State, Data, 2> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; typedef state0 result_type; result_type operator ()( typename reverse_fold_impl::expr_param e , typename reverse_fold_impl::state_param s , typename reverse_fold_impl::data_param d ) const { state2 s2 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); return s0; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct fold_impl<State0, Fun, Expr, State, Data, 3> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef state3 result_type; result_type operator ()( typename fold_impl::expr_param e , typename fold_impl::state_param s , typename fold_impl::data_param d ) const { state0 s0 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); return s3; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct reverse_fold_impl<State0, Fun, Expr, State, Data, 3> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; typedef state0 result_type; result_type operator ()( typename reverse_fold_impl::expr_param e , typename reverse_fold_impl::state_param s , typename reverse_fold_impl::data_param d ) const { state3 s3 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); return s0; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct fold_impl<State0, Fun, Expr, State, Data, 4> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef state4 result_type; result_type operator ()( typename fold_impl::expr_param e , typename fold_impl::state_param s , typename fold_impl::data_param d ) const { state0 s0 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); return s4; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct reverse_fold_impl<State0, Fun, Expr, State, Data, 4> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; typedef state0 result_type; result_type operator ()( typename reverse_fold_impl::expr_param e , typename reverse_fold_impl::state_param s , typename reverse_fold_impl::data_param d ) const { state4 s4 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); return s0; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct fold_impl<State0, Fun, Expr, State, Data, 5> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef state5 result_type; result_type operator ()( typename fold_impl::expr_param e , typename fold_impl::state_param s , typename fold_impl::data_param d ) const { state0 s0 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); return s5; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct reverse_fold_impl<State0, Fun, Expr, State, Data, 5> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; typedef state0 result_type; result_type operator ()( typename reverse_fold_impl::expr_param e , typename reverse_fold_impl::state_param s , typename reverse_fold_impl::data_param d ) const { state5 s5 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); return s0; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct fold_impl<State0, Fun, Expr, State, Data, 6> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef state6 result_type; result_type operator ()( typename fold_impl::expr_param e , typename fold_impl::state_param s , typename fold_impl::data_param d ) const { state0 s0 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); return s6; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct reverse_fold_impl<State0, Fun, Expr, State, Data, 6> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; typedef state0 result_type; result_type operator ()( typename reverse_fold_impl::expr_param e , typename reverse_fold_impl::state_param s , typename reverse_fold_impl::data_param d ) const { state6 s6 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); return s0; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct fold_impl<State0, Fun, Expr, State, Data, 7> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef state7 result_type; result_type operator ()( typename fold_impl::expr_param e , typename fold_impl::state_param s , typename fold_impl::data_param d ) const { state0 s0 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); return s7; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct reverse_fold_impl<State0, Fun, Expr, State, Data, 7> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; typedef state0 result_type; result_type operator ()( typename reverse_fold_impl::expr_param e , typename reverse_fold_impl::state_param s , typename reverse_fold_impl::data_param d ) const { state7 s7 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); return s0; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct fold_impl<State0, Fun, Expr, State, Data, 8> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8; typedef state8 result_type; result_type operator ()( typename fold_impl::expr_param e , typename fold_impl::state_param s , typename fold_impl::data_param d ) const { state0 s0 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); return s8; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct reverse_fold_impl<State0, Fun, Expr, State, Data, 8> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; typedef state0 result_type; result_type operator ()( typename reverse_fold_impl::expr_param e , typename reverse_fold_impl::state_param s , typename reverse_fold_impl::data_param d ) const { state8 s8 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); return s0; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct fold_impl<State0, Fun, Expr, State, Data, 9> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >::result_type state9; typedef state9 result_type; result_type operator ()( typename fold_impl::expr_param e , typename fold_impl::state_param s , typename fold_impl::data_param d ) const { state0 s0 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >()( proto::child_c< 8>(e) , s8 , d ); return s9; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct reverse_fold_impl<State0, Fun, Expr, State, Data, 9> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state9; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; typedef state0 result_type; result_type operator ()( typename reverse_fold_impl::expr_param e , typename reverse_fold_impl::state_param s , typename reverse_fold_impl::data_param d ) const { state9 s9 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >()( proto::child_c<8>(e) , s9 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); return s0; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct fold_impl<State0, Fun, Expr, State, Data, 10> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >::result_type state9; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 9>::type , state9 , Data >::result_type state10; typedef state10 result_type; result_type operator ()( typename fold_impl::expr_param e , typename fold_impl::state_param s , typename fold_impl::data_param d ) const { state0 s0 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >()( proto::child_c< 8>(e) , s8 , d ); state10 s10 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 9>::type , state9 , Data >()( proto::child_c< 9>(e) , s9 , d ); return s10; } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct reverse_fold_impl<State0, Fun, Expr, State, Data, 10> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state10; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 9 >::type , state10 , Data >::result_type state9; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; typedef state0 result_type; result_type operator ()( typename reverse_fold_impl::expr_param e , typename reverse_fold_impl::state_param s , typename reverse_fold_impl::data_param d ) const { state10 s10 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 9 >::type , state10 , Data >()( proto::child_c<9>(e) , s10 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >()( proto::child_c<8>(e) , s9 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); return s0; } }; PK �J�[rvj�� � 5 transform/detail/preprocessed/construct_pod_funop.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file construct_pod_funop.hpp /// Overloads of construct_\<\>::operator(). // // Copyright 2008 Eric Niebler. 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) template<typename A0> BOOST_FORCEINLINE Type operator ()(A0 &a0) const { Type that = {a0}; return that; } template<typename A0 , typename A1> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1) const { Type that = {a0 , a1}; return that; } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const { Type that = {a0 , a1 , a2}; return that; } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const { Type that = {a0 , a1 , a2 , a3}; return that; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const { Type that = {a0 , a1 , a2 , a3 , a4}; return that; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const { Type that = {a0 , a1 , a2 , a3 , a4 , a5}; return that; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const { Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6}; return that; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const { Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7}; return that; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const { Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8}; return that; } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> BOOST_FORCEINLINE Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const { Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9}; return that; } PK �J�[-���S �S & transform/detail/preprocessed/call.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file call.hpp /// Contains definition of the call<> transform. // // Copyright 2008 Eric Niebler. 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) template<typename Fun , typename A0> struct call<Fun(A0...)> : transform<call<Fun(A0...)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename detail::expand_pattern< proto::arity_of<Expr>::value , A0 , detail::expand_pattern_rest_0< Fun > >::type >::template impl<Expr, State, Data> {}; }; template<typename Fun , typename A0 , typename A1> struct call<Fun(A0 , A1...)> : transform<call<Fun(A0 , A1...)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename detail::expand_pattern< proto::arity_of<Expr>::value , A1 , detail::expand_pattern_rest_1< Fun , A0 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Fun , typename A0 , typename A1 , typename A2> struct call<Fun(A0 , A1 , A2...)> : transform<call<Fun(A0 , A1 , A2...)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename detail::expand_pattern< proto::arity_of<Expr>::value , A2 , detail::expand_pattern_rest_2< Fun , A0 , A1 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3> struct call<Fun(A0 , A1 , A2 , A3)> : transform<call<Fun(A0 , A1 , A2 , A3)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3)> function_traits; typedef typename function_traits::result_type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typedef typename function_traits::function_type function_type; return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d))); } }; }; template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3> struct call<Fun(A0 , A1 , A2 , A3...)> : transform<call<Fun(A0 , A1 , A2 , A3...)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename detail::expand_pattern< proto::arity_of<Expr>::value , A3 , detail::expand_pattern_rest_3< Fun , A0 , A1 , A2 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct call<Fun(A0 , A1 , A2 , A3 , A4)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4)> function_traits; typedef typename function_traits::result_type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typedef typename function_traits::function_type function_type; return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d))); } }; }; template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct call<Fun(A0 , A1 , A2 , A3 , A4...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4...)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename detail::expand_pattern< proto::arity_of<Expr>::value , A4 , detail::expand_pattern_rest_4< Fun , A0 , A1 , A2 , A3 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5)> function_traits; typedef typename function_traits::result_type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typedef typename function_traits::function_type function_type; return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d))); } }; }; template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5...)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename detail::expand_pattern< proto::arity_of<Expr>::value , A5 , detail::expand_pattern_rest_5< Fun , A0 , A1 , A2 , A3 , A4 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6)> function_traits; typedef typename function_traits::result_type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typedef typename function_traits::function_type function_type; return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d))); } }; }; template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename detail::expand_pattern< proto::arity_of<Expr>::value , A6 , detail::expand_pattern_rest_6< Fun , A0 , A1 , A2 , A3 , A4 , A5 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7)> function_traits; typedef typename function_traits::result_type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typedef typename function_traits::function_type function_type; return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d))); } }; }; template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename detail::expand_pattern< proto::arity_of<Expr>::value , A7 , detail::expand_pattern_rest_7< Fun , A0 , A1 , A2 , A3 , A4 , A5 , A6 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; typedef typename when<_, A8>::template impl<Expr, State, Data> a8; typedef typename a8::result_type b8; typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7 , b8)> function_traits; typedef typename function_traits::result_type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typedef typename function_traits::function_type function_type; return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)) , detail::as_lvalue(a8()(e, s, d))); } }; }; template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename detail::expand_pattern< proto::arity_of<Expr>::value , A8 , detail::expand_pattern_rest_8< Fun , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 > >::type >::template impl<Expr, State, Data> {}; }; template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; typedef typename when<_, A8>::template impl<Expr, State, Data> a8; typedef typename a8::result_type b8; typedef typename when<_, A9>::template impl<Expr, State, Data> a9; typedef typename a9::result_type b9; typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7 , b8 , b9)> function_traits; typedef typename function_traits::result_type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typedef typename function_traits::function_type function_type; return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)) , detail::as_lvalue(a8()(e, s, d)) , detail::as_lvalue(a9()(e, s, d))); } }; }; template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename detail::expand_pattern< proto::arity_of<Expr>::value , A9 , detail::expand_pattern_rest_9< Fun , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 > >::type >::template impl<Expr, State, Data> {}; }; PK �J�[E�Y q q 5 transform/detail/preprocessed/make_gcc_workaround.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file make_gcc_workaround.hpp /// Special workaround code to make the make\<\> transform work on certain /// versions of gcc. // // Copyright 2008 Eric Niebler. 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) template<typename Tag, typename Args, long Arity > struct make<proto::expr<Tag, Args, Arity>()> : transform<make<proto::expr<Tag, Args, Arity>()> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::expr<Tag, Args, Arity>::make( ); } }; }; template<typename Tag, typename Args, long Arity > struct make<proto::basic_expr<Tag, Args, Arity>()> : transform<make<proto::basic_expr<Tag, Args, Arity>()> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::basic_expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::basic_expr<Tag, Args, Arity>::make( ); } }; }; template<typename Tag, typename Args, long Arity , typename A0> struct make<proto::expr<Tag, Args, Arity>(A0)> : transform<make<proto::expr<Tag, Args, Arity>(A0)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0> struct make<proto::basic_expr<Tag, Args, Arity>(A0)> : transform<make<proto::basic_expr<Tag, Args, Arity>(A0)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::basic_expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::basic_expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1> struct make<proto::expr<Tag, Args, Arity>(A0 , A1)> : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1> struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1)> : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::basic_expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::basic_expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2> struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2)> : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2> struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2)> : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::basic_expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::basic_expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3> struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3> struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::basic_expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::basic_expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::basic_expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::basic_expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::basic_expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::basic_expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::basic_expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::basic_expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::basic_expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::basic_expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::basic_expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::basic_expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::basic_expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::basic_expr<Tag, Args, Arity>::make( detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) ) ); } }; }; PK �J�[9�'D D transform/detail/pack.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file pack.hpp /// Contains helpers for pseudo-pack expansion. // // Copyright 2012 Eric Niebler. 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_PROTO_TRANSFORM_DETAIL_PACK_HPP_EAN_2012_07_11 #define BOOST_PROTO_TRANSFORM_DETAIL_PACK_HPP_EAN_2012_07_11 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/arithmetic/inc.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/arithmetic/sub.hpp> #include <boost/preprocessor/punctuation/comma_if.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/iteration/local.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/assert.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/proto/proto_fwd.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable: 4348) // redefinition of default parameter #endif namespace boost { namespace proto { namespace detail { template<typename Fun> struct msvc_fun_workaround; template<typename Tfx, typename T> struct expand_pattern_helper { typedef T type; typedef mpl::false_ applied; }; template<typename Tfx, typename Fun> struct expand_pattern_helper<Tfx, Fun *> : expand_pattern_helper<Tfx, Fun> {}; template<typename Tfx, typename T> struct expand_pattern_helper<Tfx, pack(T)> { // BUGBUG fix me. See comment in transform/detail/call.hpp BOOST_MPL_ASSERT_MSG( (is_same<T, _>::value) , PACK_EXPANSIONS_OF_EXPRESSIONS_OTHER_THAN_THE_CURRENT_NOT_YET_SUPPORTED , (T) ); typedef Tfx type(T); typedef mpl::true_ applied; }; template<typename Tfx> struct expand_pattern_helper<Tfx, pack(_)> { typedef Tfx type; typedef mpl::true_ applied; }; #include <boost/proto/transform/detail/expand_pack.hpp> template<long Arity, typename Fun, typename Cont> struct expand_pattern; template<typename Fun, typename Cont> struct expand_pattern<0, Fun, Cont> : Cont::template cat<typename expand_pattern_helper<proto::_value, Fun>::type> { BOOST_MPL_ASSERT_MSG( (expand_pattern_helper<proto::_value, Fun>::applied::value) , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION , (Fun) ); }; #include <boost/proto/transform/detail/pack_impl.hpp> } }} #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[6� � � transform/detail/pack_impl.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/transform/detail/preprocessed/pack_impl.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/pack_impl.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file pack_impl.hpp /// Contains helpers for pseudo-pack expansion. // // Copyright 2012 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY), <boost/proto/transform/detail/pack_impl.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else #if BOOST_PP_ITERATION_DEPTH() == 1 #define N BOOST_PP_ITERATION() #define M BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N) #define M0(Z, X, D) typename expand_pattern_helper<proto::_child_c<X>, Fun>::type template<typename Fun, typename Cont> struct expand_pattern<BOOST_PP_INC(N), Fun, Cont> : Cont::template cat<BOOST_PP_ENUM(BOOST_PP_INC(N), M0, ~)> { BOOST_MPL_ASSERT_MSG( (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN , (Fun) ); }; template<typename Ret BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct BOOST_PP_CAT(expand_pattern_rest_, N) { template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_INC(M), typename C, void)> struct cat; #define BOOST_PP_ITERATION_PARAMS_2 \ (3, (1, M, <boost/proto/transform/detail/pack_impl.hpp>)) #include BOOST_PP_ITERATE() }; #undef M0 #undef M #undef N #else #define I BOOST_PP_ITERATION() #define J BOOST_PP_RELATIVE_ITERATION(1) template<BOOST_PP_ENUM_PARAMS(I, typename C)> struct cat<BOOST_PP_ENUM_PARAMS(I, C)> { typedef msvc_fun_workaround<Ret(BOOST_PP_ENUM_PARAMS(J, A) BOOST_PP_COMMA_IF(J) BOOST_PP_ENUM_PARAMS(I, C))> type; }; #undef J #undef I #endif #endif PK �J�[�]��� � $ transform/detail/construct_funop.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/transform/detail/preprocessed/construct_funop.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/construct_funop.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file construct_funop.hpp /// Overloads of construct_\<\>::operator(). // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/construct_funop.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else #define N BOOST_PP_ITERATION() template<BOOST_PP_ENUM_PARAMS(N, typename A)> BOOST_FORCEINLINE Type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, &a)) const { return Type(BOOST_PP_ENUM_PARAMS(N, a)); } #undef N #endif PK �J�[ϕ�Q transform/detail/expand_pack.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/transform/detail/preprocessed/expand_pack.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/expand_pack.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file expand_pack.hpp /// Contains helpers for pseudo-pack expansion. // // Copyright 2012 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/expand_pack.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else #define N BOOST_PP_ITERATION() #define M0(Z, X, DATA) typename expand_pattern_helper<Tfx, BOOST_PP_CAT(A, X)>::type #define M1(Z, X, DATA) expand_pattern_helper<Tfx, BOOST_PP_CAT(A, X)>::applied::value || template<typename Tfx, typename Ret BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct expand_pattern_helper<Tfx, Ret(BOOST_PP_ENUM_PARAMS(N, A))> { typedef Ret (*type)(BOOST_PP_ENUM(N, M0, ~)); typedef mpl::bool_<BOOST_PP_REPEAT(N, M1, ~) false> applied; }; #undef M1 #undef M0 #undef N #endif PK �J�[xhB]� � transform/detail/fold_impl.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/transform/detail/preprocessed/fold_impl.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_CHILD_N_TYPE(N) \ BOOST_PP_CAT(proto_child, N) \ /**/ #define BOOST_PROTO_FOLD_STATE_TYPE(Z, N, DATA) \ typedef \ typename when<_, Fun>::template impl< \ typename result_of::child_c<Expr, N>::type \ , BOOST_PP_CAT(state, N) \ , Data \ >::result_type \ BOOST_PP_CAT(state, BOOST_PP_INC(N)); \ /**/ #define BOOST_PROTO_FOLD_STATE(Z, N, DATA) \ BOOST_PP_CAT(state, BOOST_PP_INC(N)) \ BOOST_PP_CAT(s, BOOST_PP_INC(N)) \ = typename when<_, Fun>::template impl< \ typename result_of::child_c<Expr, N>::type \ , BOOST_PP_CAT(state, N) \ , Data \ >()( \ proto::child_c<N>(e) \ , BOOST_PP_CAT(s, N) \ , d \ ); \ /**/ #define BOOST_PROTO_REVERSE_FOLD_STATE_TYPE(Z, N, DATA) \ typedef \ typename when<_, Fun>::template impl< \ typename result_of::child_c< \ Expr \ , BOOST_PP_SUB(DATA, BOOST_PP_INC(N)) \ >::type \ , BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, N)) \ , Data \ >::result_type \ BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))); \ /**/ #define BOOST_PROTO_REVERSE_FOLD_STATE(Z, N, DATA) \ BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))) \ BOOST_PP_CAT(s, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))) \ = typename when<_, Fun>::template impl< \ typename result_of::child_c< \ Expr \ , BOOST_PP_SUB(DATA, BOOST_PP_INC(N)) \ >::type \ , BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, N)) \ , Data \ >()( \ proto::child_c<BOOST_PP_SUB(DATA, BOOST_PP_INC(N))>(e) \ , BOOST_PP_CAT(s, BOOST_PP_SUB(DATA, N)) \ , d \ ); \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/fold_impl.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file fold_impl.hpp /// Contains definition of fold_impl<> and reverse_fold_impl<> templates. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/fold_impl.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_REVERSE_FOLD_STATE #undef BOOST_PROTO_REVERSE_FOLD_STATE_TYPE #undef BOOST_PROTO_FOLD_STATE #undef BOOST_PROTO_FOLD_STATE_TYPE #undef BOOST_PROTO_CHILD_N_TYPE #else #define N BOOST_PP_ITERATION() template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct fold_impl<State0, Fun, Expr, State, Data, N> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; BOOST_PP_REPEAT(N, BOOST_PROTO_FOLD_STATE_TYPE, N) typedef BOOST_PP_CAT(state, N) result_type; result_type operator ()( typename fold_impl::expr_param e , typename fold_impl::state_param s , typename fold_impl::data_param d ) const { state0 s0 = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); BOOST_PP_REPEAT(N, BOOST_PROTO_FOLD_STATE, N) return BOOST_PP_CAT(s, N); } }; template<typename State0, typename Fun, typename Expr, typename State, typename Data> struct reverse_fold_impl<State0, Fun, Expr, State, Data, N> : transform_impl<Expr, State, Data> { typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type BOOST_PP_CAT(state, N); BOOST_PP_REPEAT(N, BOOST_PROTO_REVERSE_FOLD_STATE_TYPE, N) typedef state0 result_type; result_type operator ()( typename reverse_fold_impl::expr_param e , typename reverse_fold_impl::state_param s , typename reverse_fold_impl::data_param d ) const { BOOST_PP_CAT(state, N) BOOST_PP_CAT(s, N) = typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); BOOST_PP_REPEAT(N, BOOST_PROTO_REVERSE_FOLD_STATE, N) return s0; } }; #undef N #endif PK �J�[`��g� � ( transform/detail/construct_pod_funop.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/transform/detail/preprocessed/construct_pod_funop.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/construct_pod_funop.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file construct_pod_funop.hpp /// Overloads of construct_\<\>::operator(). // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/construct_pod_funop.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #else #define N BOOST_PP_ITERATION() template<BOOST_PP_ENUM_PARAMS(N, typename A)> BOOST_FORCEINLINE Type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, &a)) const { Type that = {BOOST_PP_ENUM_PARAMS(N, a)}; return that; } #undef N #endif PK �J�[�)� � transform/detail/call.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #include <boost/proto/transform/detail/preprocessed/call.hpp> #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_NTH_RESULT_TYPE(Z, M, DATA) \ typedef \ typename when<_, BOOST_PP_CAT(A, M)>::template impl<Expr, State, Data> \ BOOST_PP_CAT(a, M); \ typedef typename BOOST_PP_CAT(a, M)::result_type BOOST_PP_CAT(b, M); \ /**/ #define BOOST_PROTO_NTH_RESULT(Z, M, DATA) \ detail::as_lvalue(BOOST_PP_CAT(a, M)()(e, s, d)) \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/call.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file call.hpp /// Contains definition of the call<> transform. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/call.hpp>)) #include BOOST_PP_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_NTH_RESULT #undef BOOST_PROTO_NTH_RESULT_TYPE #else #define N BOOST_PP_ITERATION() #if N > 3 /// \brief Call the PolymorphicFunctionObject \c Fun with the /// current expression, state and data, transformed according /// to \c A0 through \c AN. template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct call<Fun(BOOST_PP_ENUM_PARAMS(N, A))> : transform<call<Fun(BOOST_PP_ENUM_PARAMS(N, A))> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { BOOST_PP_REPEAT(N, BOOST_PROTO_NTH_RESULT_TYPE, ~) typedef detail::poly_function_traits<Fun, Fun(BOOST_PP_ENUM_PARAMS(N, b))> function_traits; typedef typename function_traits::result_type result_type; /// Let \c ax be <tt>when\<_, Ax\>()(e, s, d)</tt> /// for each \c x in <tt>[0,N]</tt>. /// Return <tt>Fun()(a0, a1,... aN)</tt>. /// /// \param e The current expression /// \param s The current state /// \param d An arbitrary data BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typedef typename function_traits::function_type function_type; return function_type()(BOOST_PP_ENUM(N, BOOST_PROTO_NTH_RESULT, ~)); } }; }; #endif #if N > 0 /// \brief Call the PolymorphicFunctionObject \c Fun with the /// current expression, state and data, transformed according /// to \c A0 through \c AN. template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct call<Fun(BOOST_PP_ENUM_PARAMS(N, A)...)> : transform<call<Fun(BOOST_PP_ENUM_PARAMS(N, A)...)> > { template<typename Expr, typename State, typename Data> struct impl : call< typename detail::expand_pattern< proto::arity_of<Expr>::value // BUGBUG this isn't right. Could be pack(_child), should use arity of child! , BOOST_PP_CAT(A, BOOST_PP_DEC(N)) , detail::BOOST_PP_CAT(expand_pattern_rest_, BOOST_PP_DEC(N))< Fun BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_DEC(N), A) > >::type >::template impl<Expr, State, Data> {}; }; #endif #undef N #endif PK �J�['[�d d ( transform/detail/make_gcc_workaround.hppnu �[��� #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) #if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0) #include <boost/proto/transform/detail/preprocessed/make_gcc_workaround.hpp> #endif #elif !defined(BOOST_PP_IS_ITERATING) #define BOOST_PROTO_EXPR_MAKE_ARG(Z, M, DATA) \ detail::as_lvalue( \ typename when<_, BOOST_PP_CAT(A, M)>::template impl<Expr, State, Data>()(e, s, d) \ ) \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_gcc_workaround.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file make_gcc_workaround.hpp /// Special workaround code to make the make\<\> transform work on certain /// versions of gcc. // // Copyright 2008 Eric Niebler. 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(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif #if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0) || \ (defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)) #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/make_gcc_workaround.hpp>)) #include BOOST_PP_ITERATE() #endif #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(output: null) #endif #undef BOOST_PROTO_EXPR_MAKE_ARG #else #define N BOOST_PP_ITERATION() // work around GCC bug template<typename Tag, typename Args, long Arity BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct make<proto::expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> : transform<make<proto::expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::expr<Tag, Args, Arity>::make( BOOST_PP_ENUM(N, BOOST_PROTO_EXPR_MAKE_ARG, DATA) ); } }; }; template<typename Tag, typename Args, long Arity BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> struct make<proto::basic_expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> : transform<make<proto::basic_expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef proto::basic_expr<Tag, Args, Arity> result_type; BOOST_FORCEINLINE result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { return proto::basic_expr<Tag, Args, Arity>::make( BOOST_PP_ENUM(N, BOOST_PROTO_EXPR_MAKE_ARG, DATA) ); } }; }; #undef N #endif PK �J�[ۏ�d? d? transform/call.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file call.hpp /// Contains definition of the call<> transform. // // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_CALL_HPP_EAN_11_02_2007 #define BOOST_PROTO_TRANSFORM_CALL_HPP_EAN_11_02_2007 #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable: 4714) // function 'xxx' marked as __forceinline not inlined #endif #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/ref.hpp> #include <boost/utility/result_of.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/proto/detail/as_lvalue.hpp> #include <boost/proto/detail/poly_function.hpp> #include <boost/proto/transform/detail/pack.hpp> namespace boost { namespace proto { /// \brief Wrap \c PrimitiveTransform so that <tt>when\<\></tt> knows /// it is callable. Requires that the parameter is actually a /// PrimitiveTransform. /// /// This form of <tt>call\<\></tt> is useful for annotating an /// arbitrary PrimitiveTransform as callable when using it with /// <tt>when\<\></tt>. Consider the following transform, which /// is parameterized with another transform. /// /// \code /// template<typename Grammar> /// struct Foo /// : when< /// unary_plus<Grammar> /// , Grammar(_child) // May or may not work. /// > /// {}; /// \endcode /// /// The problem with the above is that <tt>when\<\></tt> may or /// may not recognize \c Grammar as callable, depending on how /// \c Grammar is implemented. (See <tt>is_callable\<\></tt> for /// a discussion of this issue.) You can guard against /// the issue by wrapping \c Grammar in <tt>call\<\></tt>, such /// as: /// /// \code /// template<typename Grammar> /// struct Foo /// : when< /// unary_plus<Grammar> /// , call<Grammar>(_child) // OK, this works /// > /// {}; /// \endcode /// /// The above could also have been written as: /// /// \code /// template<typename Grammar> /// struct Foo /// : when< /// unary_plus<Grammar> /// , call<Grammar(_child)> // OK, this works, too /// > /// {}; /// \endcode template<typename PrimitiveTransform> struct call : PrimitiveTransform {}; /// \brief A specialization that treats function pointer Transforms as /// if they were function type Transforms. /// /// This specialization requires that \c Fun is actually a function type. /// /// This specialization is required for nested transforms such as /// <tt>call\<T0(T1(_))\></tt>. In C++, functions that are used as /// parameters to other functions automatically decay to funtion /// pointer types. In other words, the type <tt>T0(T1(_))</tt> is /// indistinguishable from <tt>T0(T1(*)(_))</tt>. This specialization /// is required to handle these nested function pointer type transforms /// properly. template<typename Fun> struct call<Fun *> : call<Fun> {}; /// INTERNAL ONLY template<typename Fun> struct call<detail::msvc_fun_workaround<Fun> > : call<Fun> {}; /// \brief Either call the PolymorphicFunctionObject with 0 /// arguments, or invoke the PrimitiveTransform with 3 /// arguments. template<typename Fun> struct call<Fun()> : transform<call<Fun()> > { /// INTERNAL ONLY template<typename Expr, typename State, typename Data, bool B> struct impl2 : transform_impl<Expr, State, Data> { typedef typename BOOST_PROTO_RESULT_OF<Fun()>::type result_type; BOOST_FORCEINLINE result_type operator()( typename impl2::expr_param , typename impl2::state_param , typename impl2::data_param ) const { return Fun()(); } }; /// INTERNAL ONLY template<typename Expr, typename State, typename Data> struct impl2<Expr, State, Data, true> : Fun::template impl<Expr, State, Data> {}; /// Either call the PolymorphicFunctionObject \c Fun with 0 arguments; or /// invoke the PrimitiveTransform \c Fun with 3 arguments: the current /// expression, state, and data. /// /// If \c Fun is a nullary PolymorphicFunctionObject, return <tt>Fun()()</tt>. /// Otherwise, return <tt>Fun()(e, s, d)</tt>. /// /// \param e The current expression /// \param s The current state /// \param d An arbitrary data /// If \c Fun is a nullary PolymorphicFunctionObject, \c type is a typedef /// for <tt>boost::result_of\<Fun()\>::type</tt>. Otherwise, it is /// a typedef for <tt>boost::result_of\<Fun(Expr, State, Data)\>::type</tt>. template<typename Expr, typename State, typename Data> struct impl : impl2<Expr, State, Data, detail::is_transform_<Fun>::value> {}; }; /// \brief Either call the PolymorphicFunctionObject with 1 /// argument, or invoke the PrimitiveTransform with 3 /// arguments. template<typename Fun, typename A0> struct call<Fun(A0)> : transform<call<Fun(A0)> > { template<typename Expr, typename State, typename Data, bool B> struct impl2 : transform_impl<Expr, State, Data> { typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; typedef typename detail::poly_function_traits<Fun, Fun(a0)>::result_type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl2::expr_param e , typename impl2::state_param s , typename impl2::data_param d ) const { return typename detail::poly_function_traits<Fun, Fun(a0)>::function_type()( detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d)) ); } }; template<typename Expr, typename State, typename Data> struct impl2<Expr, State, Data, true> : transform_impl<Expr, State, Data> { typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; typedef typename Fun::template impl<a0, State, Data>::result_type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl2::expr_param e , typename impl2::state_param s , typename impl2::data_param d ) const { return typename Fun::template impl<a0, State, Data>()( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) , s , d ); } }; /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt> and \c X /// be the type of \c x. /// If \c Fun is a unary PolymorphicFunctionObject that accepts \c x, /// then \c type is a typedef for <tt>boost::result_of\<Fun(X)\>::type</tt>. /// Otherwise, it is a typedef for <tt>boost::result_of\<Fun(X, State, Data)\>::type</tt>. /// Either call the PolymorphicFunctionObject with 1 argument: /// the result of applying the \c A0 transform; or /// invoke the PrimitiveTransform with 3 arguments: /// result of applying the \c A0 transform, the state, and the /// data. /// /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt>. /// If \c Fun is a unary PolymorphicFunctionObject that accepts \c x, /// then return <tt>Fun()(x)</tt>. Otherwise, return /// <tt>Fun()(x, s, d)</tt>. /// /// \param e The current expression /// \param s The current state /// \param d An arbitrary data template<typename Expr, typename State, typename Data> struct impl : impl2<Expr, State, Data, detail::is_transform_<Fun>::value> {}; }; /// \brief Either call the PolymorphicFunctionObject with 2 /// arguments, or invoke the PrimitiveTransform with 3 /// arguments. template<typename Fun, typename A0, typename A1> struct call<Fun(A0, A1)> : transform<call<Fun(A0, A1)> > { template<typename Expr, typename State, typename Data, bool B> struct impl2 : transform_impl<Expr, State, Data> { typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1; typedef typename detail::poly_function_traits<Fun, Fun(a0, a1)>::result_type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl2::expr_param e , typename impl2::state_param s , typename impl2::data_param d ) const { return typename detail::poly_function_traits<Fun, Fun(a0, a1)>::function_type()( detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d)) , detail::as_lvalue(typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d)) ); } }; template<typename Expr, typename State, typename Data> struct impl2<Expr, State, Data, true> : transform_impl<Expr, State, Data> { typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1; typedef typename Fun::template impl<a0, a1, Data>::result_type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl2::expr_param e , typename impl2::state_param s , typename impl2::data_param d ) const { return typename Fun::template impl<a0, a1, Data>()( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) , typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) , d ); } }; /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt> and \c X /// be the type of \c x. /// Let \c y be <tt>when\<_, A1\>()(e, s, d)</tt> and \c Y /// be the type of \c y. /// If \c Fun is a binary PolymorphicFunction object that accepts \c x /// and \c y, then \c type is a typedef for /// <tt>boost::result_of\<Fun(X, Y)\>::type</tt>. Otherwise, it is /// a typedef for <tt>boost::result_of\<Fun(X, Y, Data)\>::type</tt>. /// Either call the PolymorphicFunctionObject with 2 arguments: /// the result of applying the \c A0 transform, and the /// result of applying the \c A1 transform; or invoke the /// PrimitiveTransform with 3 arguments: the result of applying /// the \c A0 transform, the result of applying the \c A1 /// transform, and the data. /// /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt>. /// Let \c y be <tt>when\<_, A1\>()(e, s, d)</tt>. /// If \c Fun is a binary PolymorphicFunction object that accepts \c x /// and \c y, return <tt>Fun()(x, y)</tt>. Otherwise, return /// <tt>Fun()(x, y, d)</tt>. /// /// \param e The current expression /// \param s The current state /// \param d An arbitrary data template<typename Expr, typename State, typename Data> struct impl : impl2<Expr, State, Data, detail::is_transform_<Fun>::value> {}; }; /// \brief Call the PolymorphicFunctionObject or the /// PrimitiveTransform with the current expression, state /// and data, transformed according to \c A0, \c A1, and /// \c A2, respectively. template<typename Fun, typename A0, typename A1, typename A2> struct call<Fun(A0, A1, A2)> : transform<call<Fun(A0, A1, A2)> > { template<typename Expr, typename State, typename Data, bool B> struct impl2 : transform_impl<Expr, State, Data> { typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1; typedef typename when<_, A2>::template impl<Expr, State, Data>::result_type a2; typedef typename detail::poly_function_traits<Fun, Fun(a0, a1, a2)>::result_type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl2::expr_param e , typename impl2::state_param s , typename impl2::data_param d ) const { return typename detail::poly_function_traits<Fun, Fun(a0, a1, a2)>::function_type()( detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d)) , detail::as_lvalue(typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d)) , detail::as_lvalue(typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d)) ); } }; template<typename Expr, typename State, typename Data> struct impl2<Expr, State, Data, true> : transform_impl<Expr, State, Data> { typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1; typedef typename when<_, A2>::template impl<Expr, State, Data>::result_type a2; typedef typename Fun::template impl<a0, a1, a2>::result_type result_type; BOOST_FORCEINLINE result_type operator ()( typename impl2::expr_param e , typename impl2::state_param s , typename impl2::data_param d ) const { return typename Fun::template impl<a0, a1, a2>()( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) , typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) , typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ); } }; /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt>. /// Let \c y be <tt>when\<_, A1\>()(e, s, d)</tt>. /// Let \c z be <tt>when\<_, A2\>()(e, s, d)</tt>. /// Return <tt>Fun()(x, y, z)</tt>. /// /// \param e The current expression /// \param s The current state /// \param d An arbitrary data template<typename Expr, typename State, typename Data> struct impl : impl2<Expr, State, Data, detail::is_transform_<Fun>::value> {}; }; #include <boost/proto/transform/detail/call.hpp> /// INTERNAL ONLY /// template<typename Fun> struct is_callable<call<Fun> > : mpl::true_ {}; }} // namespace boost::proto #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[!Ԉl^ ^ transform/fold_tree.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file fold_tree.hpp /// Contains definition of the fold_tree<> and reverse_fold_tree<> transforms. // // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_FOLD_TREE_HPP_EAN_11_05_2007 #define BOOST_PROTO_TRANSFORM_FOLD_TREE_HPP_EAN_11_05_2007 #include <boost/type_traits/is_same.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/matches.hpp> #include <boost/proto/transform/fold.hpp> #include <boost/proto/transform/impl.hpp> namespace boost { namespace proto { namespace detail { template<typename Tag> struct has_tag { template<typename Expr, typename State, typename Data, typename EnableIf = Tag> struct impl { typedef mpl::false_ result_type; }; template<typename Expr, typename State, typename Data> struct impl<Expr, State, Data, typename Expr::proto_tag> { typedef mpl::true_ result_type; }; template<typename Expr, typename State, typename Data> struct impl<Expr &, State, Data, typename Expr::proto_tag> { typedef mpl::true_ result_type; }; }; template<typename Tag, typename Fun> struct fold_tree_ : if_<has_tag<Tag>, fold<_, _state, fold_tree_<Tag, Fun> >, Fun> {}; template<typename Tag, typename Fun> struct reverse_fold_tree_ : if_<has_tag<Tag>, reverse_fold<_, _state, reverse_fold_tree_<Tag, Fun> >, Fun> {}; } /// \brief A PrimitiveTransform that recursively applies the /// <tt>fold\<\></tt> transform to sub-trees that all share a common /// tag type. /// /// <tt>fold_tree\<\></tt> is useful for flattening trees into lists; /// for example, you might use <tt>fold_tree\<\></tt> to flatten an /// expression tree like <tt>a | b | c</tt> into a Fusion list like /// <tt>cons(c, cons(b, cons(a)))</tt>. /// /// <tt>fold_tree\<\></tt> is easily understood in terms of a /// <tt>recurse_if_\<\></tt> helper, defined as follows: /// /// \code /// template<typename Tag, typename Fun> /// struct recurse_if_ /// : if_< /// // If the current node has type "Tag" ... /// is_same<tag_of<_>, Tag>() /// // ... recurse, otherwise ... /// , fold<_, _state, recurse_if_<Tag, Fun> > /// // ... apply the Fun transform. /// , Fun /// > /// {}; /// \endcode /// /// With <tt>recurse_if_\<\></tt> as defined above, /// <tt>fold_tree\<Sequence, State0, Fun\>()(e, s, d)</tt> is /// equivalent to /// <tt>fold<Sequence, State0, recurse_if_<Expr::proto_tag, Fun> >()(e, s, d).</tt> /// It has the effect of folding a tree front-to-back, recursing into /// child nodes that share a tag type with the parent node. template<typename Sequence, typename State0, typename Fun> struct fold_tree : transform<fold_tree<Sequence, State0, Fun> > { template<typename Expr, typename State, typename Data> struct impl : fold< Sequence , State0 , detail::fold_tree_<typename Expr::proto_tag, Fun> >::template impl<Expr, State, Data> {}; template<typename Expr, typename State, typename Data> struct impl<Expr &, State, Data> : fold< Sequence , State0 , detail::fold_tree_<typename Expr::proto_tag, Fun> >::template impl<Expr &, State, Data> {}; }; /// \brief A PrimitiveTransform that recursively applies the /// <tt>reverse_fold\<\></tt> transform to sub-trees that all share /// a common tag type. /// /// <tt>reverse_fold_tree\<\></tt> is useful for flattening trees into /// lists; for example, you might use <tt>reverse_fold_tree\<\></tt> to /// flatten an expression tree like <tt>a | b | c</tt> into a Fusion list /// like <tt>cons(a, cons(b, cons(c)))</tt>. /// /// <tt>reverse_fold_tree\<\></tt> is easily understood in terms of a /// <tt>recurse_if_\<\></tt> helper, defined as follows: /// /// \code /// template<typename Tag, typename Fun> /// struct recurse_if_ /// : if_< /// // If the current node has type "Tag" ... /// is_same<tag_of<_>, Tag>() /// // ... recurse, otherwise ... /// , reverse_fold<_, _state, recurse_if_<Tag, Fun> > /// // ... apply the Fun transform. /// , Fun /// > /// {}; /// \endcode /// /// With <tt>recurse_if_\<\></tt> as defined above, /// <tt>reverse_fold_tree\<Sequence, State0, Fun\>()(e, s, d)</tt> is /// equivalent to /// <tt>reverse_fold<Sequence, State0, recurse_if_<Expr::proto_tag, Fun> >()(e, s, d).</tt> /// It has the effect of folding a tree back-to-front, recursing into /// child nodes that share a tag type with the parent node. template<typename Sequence, typename State0, typename Fun> struct reverse_fold_tree : transform<reverse_fold_tree<Sequence, State0, Fun> > { template<typename Expr, typename State, typename Data> struct impl : reverse_fold< Sequence , State0 , detail::reverse_fold_tree_<typename Expr::proto_tag, Fun> >::template impl<Expr, State, Data> {}; template<typename Expr, typename State, typename Data> struct impl<Expr &, State, Data> : reverse_fold< Sequence , State0 , detail::reverse_fold_tree_<typename Expr::proto_tag, Fun> >::template impl<Expr &, State, Data> {}; }; /// INTERNAL ONLY /// template<typename Sequence, typename State0, typename Fun> struct is_callable<fold_tree<Sequence, State0, Fun> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename Sequence, typename State0, typename Fun> struct is_callable<reverse_fold_tree<Sequence, State0, Fun> > : mpl::true_ {}; }} #endif PK �J�[ S�T� � transform/pass_through.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file pass_through.hpp /// /// Definition of the pass_through transform, which is the default transform /// of all of the expression generator metafunctions such as unary_plus<>, plus<> /// and nary_expr<>. // // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_PASS_THROUGH_HPP_EAN_12_26_2006 #define BOOST_PROTO_TRANSFORM_PASS_THROUGH_HPP_EAN_12_26_2006 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/if.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/args.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/proto/detail/ignore_unused.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { template< typename Grammar , typename Domain , typename Expr , typename State , typename Data , long Arity = arity_of<Expr>::value > struct pass_through_impl {}; #include <boost/proto/transform/detail/pass_through_impl.hpp> template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> struct pass_through_impl<Grammar, Domain, Expr, State, Data, 0> : transform_impl<Expr, State, Data> { typedef Expr result_type; /// \param e An expression /// \return \c e /// \throw nothrow BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename pass_through_impl::expr_param) operator()( typename pass_through_impl::expr_param e , typename pass_through_impl::state_param , typename pass_through_impl::data_param ) const { return e; } }; } // namespace detail /// \brief A PrimitiveTransform that transforms the child expressions /// of an expression node according to the corresponding children of /// a Grammar. /// /// Given a Grammar such as <tt>plus\<T0, T1\></tt>, an expression type /// that matches the grammar such as <tt>plus\<E0, E1\>::type</tt>, a /// state \c S and a data \c V, the result of applying the /// <tt>pass_through\<plus\<T0, T1\> \></tt> transform is: /// /// \code /// plus< /// T0::result<T0(E0, S, V)>::type /// , T1::result<T1(E1, S, V)>::type /// >::type /// \endcode /// /// The above demonstrates how child transforms and child expressions /// are applied pairwise, and how the results are reassembled into a new /// expression node with the same tag type as the original. /// /// The explicit use of <tt>pass_through\<\></tt> is not usually needed, /// since the expression generator metafunctions such as /// <tt>plus\<\></tt> have <tt>pass_through\<\></tt> as their default /// transform. So, for instance, these are equivalent: /// /// \code /// // Within a grammar definition, these are equivalent: /// when< plus<X, Y>, pass_through< plus<X, Y> > > /// when< plus<X, Y>, plus<X, Y> > /// when< plus<X, Y> > // because of when<class X, class Y=X> /// plus<X, Y> // because plus<> is both a /// // grammar and a transform /// \endcode /// /// For example, consider the following transform that promotes all /// \c float terminals in an expression to \c double. /// /// \code /// // This transform finds all float terminals in an expression and promotes /// // them to doubles. /// struct Promote /// : or_< /// when<terminal<float>, terminal<double>::type(_value) > /// // terminal<>'s default transform is a no-op: /// , terminal<_> /// // nary_expr<> has a pass_through<> transform: /// , nary_expr<_, vararg<Promote> > /// > /// {}; /// \endcode template<typename Grammar, typename Domain /* = deduce_domain*/> struct pass_through : transform<pass_through<Grammar, Domain> > { template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<Grammar, Domain, Expr, State, Data> {}; }; /// INTERNAL ONLY /// template<typename Grammar, typename Domain> struct is_callable<pass_through<Grammar, Domain> > : mpl::true_ {}; }} // namespace boost::proto #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[Y��(r� r� traits.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file traits.hpp /// Contains definitions for child\<\>, child_c\<\>, left\<\>, /// right\<\>, tag_of\<\>, and the helper functions child(), child_c(), /// value(), left() and right(). // // Copyright 2008 Eric Niebler. 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_PROTO_ARG_TRAITS_HPP_EAN_04_01_2005 #define BOOST_PROTO_ARG_TRAITS_HPP_EAN_04_01_2005 #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/arithmetic/sub.hpp> #include <boost/static_assert.hpp> #include <boost/mpl/bool.hpp> #include <boost/proto/detail/template_arity.hpp> #include <boost/type_traits/is_pod.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/type_traits/add_const.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/args.hpp> #include <boost/proto/domain.hpp> #include <boost/proto/transform/pass_through.hpp> #if defined(_MSC_VER) # pragma warning(push) # if BOOST_WORKAROUND( BOOST_MSVC, >= 1400 ) # pragma warning(disable: 4180) // warning C4180: qualifier applied to function type has no meaning; ignored # endif # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { template<typename T, typename Void = void> struct if_vararg {}; template<typename T> struct if_vararg<T, typename T::proto_is_vararg_> : T {}; template<typename T, typename Void = void> struct is_callable2_ : mpl::false_ {}; template<typename T> struct is_callable2_<T, typename T::proto_is_callable_> : mpl::true_ {}; template<typename T BOOST_PROTO_TEMPLATE_ARITY_PARAM(long Arity = boost::proto::detail::template_arity<T>::value)> struct is_callable_ : is_callable2_<T> {}; } /// \brief Boolean metafunction which detects whether a type is /// a callable function object type or not. /// /// <tt>is_callable\<\></tt> is used by the <tt>when\<\></tt> transform /// to determine whether a function type <tt>R(A1,A2,...AN)</tt> is a /// callable transform or an object transform. (The former are evaluated /// using <tt>call\<\></tt> and the later with <tt>make\<\></tt>.) If /// <tt>is_callable\<R\>::value</tt> is \c true, the function type is /// a callable transform; otherwise, it is an object transform. /// /// Unless specialized for a type \c T, <tt>is_callable\<T\>::value</tt> /// is computed as follows: /// /// \li If \c T is a template type <tt>X\<Y0,Y1,...YN\></tt>, where all \c Yx /// are types for \c x in <tt>[0,N]</tt>, <tt>is_callable\<T\>::value</tt> /// is <tt>is_same\<YN, proto::callable\>::value</tt>. /// \li If \c T has a nested type \c proto_is_callable_ that is a typedef /// for \c void, <tt>is_callable\<T\>::value</tt> is \c true. (Note: this is /// the case for any type that derives from \c proto::callable.) /// \li Otherwise, <tt>is_callable\<T\>::value</tt> is \c false. template<typename T> struct is_callable : proto::detail::is_callable_<T> {}; /// INTERNAL ONLY /// template<> struct is_callable<proto::_> : mpl::true_ {}; /// INTERNAL ONLY /// template<> struct is_callable<proto::callable> : mpl::false_ {}; /// INTERNAL ONLY /// template<typename PrimitiveTransform, typename X> struct is_callable<proto::transform<PrimitiveTransform, X> > : mpl::false_ {}; #if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0) // work around GCC bug template<typename Tag, typename Args, long N> struct is_callable<proto::expr<Tag, Args, N> > : mpl::false_ {}; // work around GCC bug template<typename Tag, typename Args, long N> struct is_callable<proto::basic_expr<Tag, Args, N> > : mpl::false_ {}; #endif namespace detail { template<typename T, typename Void /*= void*/> struct is_transform_ : mpl::false_ {}; template<typename T> struct is_transform_<T, typename T::proto_is_transform_> : mpl::true_ {}; } /// \brief Boolean metafunction which detects whether a type is /// a PrimitiveTransform type or not. /// /// <tt>is_transform\<\></tt> is used by the <tt>call\<\></tt> transform /// to determine whether the function types <tt>R()</tt>, <tt>R(A1)</tt>, /// and <tt>R(A1, A2)</tt> should be passed the expression, state and data /// parameters (as needed). /// /// Unless specialized for a type \c T, <tt>is_transform\<T\>::value</tt> /// is computed as follows: /// /// \li If \c T has a nested type \c proto_is_transform_ that is a typedef /// for \c void, <tt>is_transform\<T\>::value</tt> is \c true. (Note: this is /// the case for any type that derives from an instantiation of \c proto::transform.) /// \li Otherwise, <tt>is_transform\<T\>::value</tt> is \c false. template<typename T> struct is_transform : proto::detail::is_transform_<T> {}; namespace detail { template<typename T, typename Void /*= void*/> struct is_aggregate_ : is_pod<T> {}; template<typename Tag, typename Args, long N> struct is_aggregate_<proto::expr<Tag, Args, N>, void> : mpl::true_ {}; template<typename Tag, typename Args, long N> struct is_aggregate_<proto::basic_expr<Tag, Args, N>, void> : mpl::true_ {}; template<typename T> struct is_aggregate_<T, typename T::proto_is_aggregate_> : mpl::true_ {}; } /// \brief A Boolean metafunction that indicates whether a type requires /// aggregate initialization. /// /// <tt>is_aggregate\<\></tt> is used by the <tt>make\<\></tt> transform /// to determine how to construct an object of some type \c T, given some /// initialization arguments <tt>a0,a1,...aN</tt>. /// If <tt>is_aggregate\<T\>::value</tt> is \c true, then an object of /// type T will be initialized as <tt>T t = {a0,a1,...aN};</tt>. Otherwise, /// it will be initialized as <tt>T t(a0,a1,...aN)</tt>. template<typename T> struct is_aggregate : proto::detail::is_aggregate_<T> {}; /// \brief A Boolean metafunction that indicates whether a given /// type \c T is a Proto expression type. /// /// If \c T has a nested type \c proto_is_expr_ that is a typedef /// for \c void, <tt>is_expr\<T\>::value</tt> is \c true. (Note, this /// is the case for <tt>proto::expr\<\></tt>, any type that is derived /// from <tt>proto::extends\<\></tt> or that uses the /// <tt>BOOST_PROTO_BASIC_EXTENDS()</tt> macro.) Otherwise, /// <tt>is_expr\<T\>::value</tt> is \c false. template<typename T, typename Void /* = void*/> struct is_expr : mpl::false_ {}; /// \brief A Boolean metafunction that indicates whether a given /// type \c T is a Proto expression type. /// /// If \c T has a nested type \c proto_is_expr_ that is a typedef /// for \c void, <tt>is_expr\<T\>::value</tt> is \c true. (Note, this /// is the case for <tt>proto::expr\<\></tt>, any type that is derived /// from <tt>proto::extends\<\></tt> or that uses the /// <tt>BOOST_PROTO_BASIC_EXTENDS()</tt> macro.) Otherwise, /// <tt>is_expr\<T\>::value</tt> is \c false. template<typename T> struct is_expr<T, typename T::proto_is_expr_> : mpl::true_ {}; template<typename T> struct is_expr<T &, void> : is_expr<T> {}; /// \brief A metafunction that returns the tag type of a /// Proto expression. template<typename Expr> struct tag_of { typedef typename Expr::proto_tag type; }; template<typename Expr> struct tag_of<Expr &> { typedef typename Expr::proto_tag type; }; /// \brief A metafunction that returns the arity of a /// Proto expression. template<typename Expr> struct arity_of : Expr::proto_arity {}; template<typename Expr> struct arity_of<Expr &> : Expr::proto_arity {}; namespace result_of { /// \brief A metafunction that computes the return type of the \c as_expr() /// function. template<typename T, typename Domain /*= default_domain*/> struct as_expr { typedef typename Domain::template as_expr<T>::result_type type; }; /// \brief A metafunction that computes the return type of the \c as_child() /// function. template<typename T, typename Domain /*= default_domain*/> struct as_child { typedef typename Domain::template as_child<T>::result_type type; }; /// \brief A metafunction that returns the type of the Nth child /// of a Proto expression, where N is an MPL Integral Constant. /// /// <tt>result_of::child\<Expr, N\></tt> is equivalent to /// <tt>result_of::child_c\<Expr, N::value\></tt>. template<typename Expr, typename N /* = mpl::long_<0>*/> struct child : child_c<Expr, N::value> {}; /// \brief A metafunction that returns the type of the value /// of a terminal Proto expression. /// template<typename Expr> struct value { /// Verify that we are actually operating on a terminal BOOST_STATIC_ASSERT(0 == Expr::proto_arity_c); /// The raw type of the Nth child as it is stored within /// \c Expr. This may be a value or a reference typedef typename Expr::proto_child0 value_type; /// The "value" type of the child, suitable for storage by value, /// computed as follows: /// \li <tt>T const(&)[N]</tt> becomes <tt>T[N]</tt> /// \li <tt>T[N]</tt> becomes <tt>T[N]</tt> /// \li <tt>T(&)[N]</tt> becomes <tt>T[N]</tt> /// \li <tt>R(&)(A0,...)</tt> becomes <tt>R(&)(A0,...)</tt> /// \li <tt>T const &</tt> becomes <tt>T</tt> /// \li <tt>T &</tt> becomes <tt>T</tt> /// \li <tt>T</tt> becomes <tt>T</tt> typedef typename detail::term_traits<typename Expr::proto_child0>::value_type type; }; template<typename Expr> struct value<Expr &> { /// Verify that we are actually operating on a terminal BOOST_STATIC_ASSERT(0 == Expr::proto_arity_c); /// The raw type of the Nth child as it is stored within /// \c Expr. This may be a value or a reference typedef typename Expr::proto_child0 value_type; /// The "reference" type of the child, suitable for storage by /// reference, computed as follows: /// \li <tt>T const(&)[N]</tt> becomes <tt>T const(&)[N]</tt> /// \li <tt>T[N]</tt> becomes <tt>T(&)[N]</tt> /// \li <tt>T(&)[N]</tt> becomes <tt>T(&)[N]</tt> /// \li <tt>R(&)(A0,...)</tt> becomes <tt>R(&)(A0,...)</tt> /// \li <tt>T const &</tt> becomes <tt>T const &</tt> /// \li <tt>T &</tt> becomes <tt>T &</tt> /// \li <tt>T</tt> becomes <tt>T &</tt> typedef typename detail::term_traits<typename Expr::proto_child0>::reference type; }; template<typename Expr> struct value<Expr const &> { /// Verify that we are actually operating on a terminal BOOST_STATIC_ASSERT(0 == Expr::proto_arity_c); /// The raw type of the Nth child as it is stored within /// \c Expr. This may be a value or a reference typedef typename Expr::proto_child0 value_type; /// The "const reference" type of the child, suitable for storage by /// const reference, computed as follows: /// \li <tt>T const(&)[N]</tt> becomes <tt>T const(&)[N]</tt> /// \li <tt>T[N]</tt> becomes <tt>T const(&)[N]</tt> /// \li <tt>T(&)[N]</tt> becomes <tt>T(&)[N]</tt> /// \li <tt>R(&)(A0,...)</tt> becomes <tt>R(&)(A0,...)</tt> /// \li <tt>T const &</tt> becomes <tt>T const &</tt> /// \li <tt>T &</tt> becomes <tt>T &</tt> /// \li <tt>T</tt> becomes <tt>T const &</tt> typedef typename detail::term_traits<typename Expr::proto_child0>::const_reference type; }; /// \brief A metafunction that returns the type of the left child /// of a binary Proto expression. /// /// <tt>result_of::left\<Expr\></tt> is equivalent to /// <tt>result_of::child_c\<Expr, 0\></tt>. template<typename Expr> struct left : child_c<Expr, 0> {}; /// \brief A metafunction that returns the type of the right child /// of a binary Proto expression. /// /// <tt>result_of::right\<Expr\></tt> is equivalent to /// <tt>result_of::child_c\<Expr, 1\></tt>. template<typename Expr> struct right : child_c<Expr, 1> {}; } // namespace result_of /// \brief A metafunction for generating terminal expression types, /// a grammar element for matching terminal expressions, and a /// PrimitiveTransform that returns the current expression unchanged. template<typename T> struct terminal : proto::transform<terminal<T>, int> { typedef proto::expr<proto::tag::terminal, term<T>, 0> type; typedef proto::basic_expr<proto::tag::terminal, term<T>, 0> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef Expr result_type; /// \param e The current expression /// \pre <tt>matches\<Expr, terminal\<T\> \>::value</tt> is \c true. /// \return \c e /// \throw nothrow BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param) operator ()( typename impl::expr_param e , typename impl::state_param , typename impl::data_param ) const { return e; } }; /// INTERNAL ONLY typedef proto::tag::terminal proto_tag; /// INTERNAL ONLY typedef T proto_child0; }; /// \brief A metafunction for generating ternary conditional expression types, /// a grammar element for matching ternary conditional expressions, and a /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt> /// transform. template<typename T, typename U, typename V> struct if_else_ : proto::transform<if_else_<T, U, V>, int> { typedef proto::expr<proto::tag::if_else_, list3<T, U, V>, 3> type; typedef proto::basic_expr<proto::tag::if_else_, list3<T, U, V>, 3> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<if_else_, deduce_domain, Expr, State, Data> {}; /// INTERNAL ONLY typedef proto::tag::if_else_ proto_tag; /// INTERNAL ONLY typedef T proto_child0; /// INTERNAL ONLY typedef U proto_child1; /// INTERNAL ONLY typedef V proto_child2; }; /// \brief A metafunction for generating nullary expression types with a /// specified tag type, /// a grammar element for matching nullary expressions, and a /// PrimitiveTransform that returns the current expression unchanged. /// /// Use <tt>nullary_expr\<_, _\></tt> as a grammar element to match any /// nullary expression. template<typename Tag, typename T> struct nullary_expr : proto::transform<nullary_expr<Tag, T>, int> { typedef proto::expr<Tag, term<T>, 0> type; typedef proto::basic_expr<Tag, term<T>, 0> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef Expr result_type; /// \param e The current expression /// \pre <tt>matches\<Expr, nullary_expr\<Tag, T\> \>::value</tt> is \c true. /// \return \c e /// \throw nothrow BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param) operator ()( typename impl::expr_param e , typename impl::state_param , typename impl::data_param ) const { return e; } }; /// INTERNAL ONLY typedef Tag proto_tag; /// INTERNAL ONLY typedef T proto_child0; }; /// \brief A metafunction for generating unary expression types with a /// specified tag type, /// a grammar element for matching unary expressions, and a /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt> /// transform. /// /// Use <tt>unary_expr\<_, _\></tt> as a grammar element to match any /// unary expression. template<typename Tag, typename T> struct unary_expr : proto::transform<unary_expr<Tag, T>, int> { typedef proto::expr<Tag, list1<T>, 1> type; typedef proto::basic_expr<Tag, list1<T>, 1> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<unary_expr, deduce_domain, Expr, State, Data> {}; /// INTERNAL ONLY typedef Tag proto_tag; /// INTERNAL ONLY typedef T proto_child0; }; /// \brief A metafunction for generating binary expression types with a /// specified tag type, /// a grammar element for matching binary expressions, and a /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt> /// transform. /// /// Use <tt>binary_expr\<_, _, _\></tt> as a grammar element to match any /// binary expression. template<typename Tag, typename T, typename U> struct binary_expr : proto::transform<binary_expr<Tag, T, U>, int> { typedef proto::expr<Tag, list2<T, U>, 2> type; typedef proto::basic_expr<Tag, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<binary_expr, deduce_domain, Expr, State, Data> {}; /// INTERNAL ONLY typedef Tag proto_tag; /// INTERNAL ONLY typedef T proto_child0; /// INTERNAL ONLY typedef U proto_child1; }; #define BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(Op) \ template<typename T> \ struct Op \ : proto::transform<Op<T>, int> \ { \ typedef proto::expr<proto::tag::Op, list1<T>, 1> type; \ typedef proto::basic_expr<proto::tag::Op, list1<T>, 1> proto_grammar; \ \ template<typename Expr, typename State, typename Data> \ struct impl \ : detail::pass_through_impl<Op, deduce_domain, Expr, State, Data> \ {}; \ \ typedef proto::tag::Op proto_tag; \ typedef T proto_child0; \ }; \ /**/ #define BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(Op) \ template<typename T, typename U> \ struct Op \ : proto::transform<Op<T, U>, int> \ { \ typedef proto::expr<proto::tag::Op, list2<T, U>, 2> type; \ typedef proto::basic_expr<proto::tag::Op, list2<T, U>, 2> proto_grammar; \ \ template<typename Expr, typename State, typename Data> \ struct impl \ : detail::pass_through_impl<Op, deduce_domain, Expr, State, Data> \ {}; \ \ typedef proto::tag::Op proto_tag; \ typedef T proto_child0; \ typedef U proto_child1; \ }; \ /**/ BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(unary_plus) BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(negate) BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(dereference) BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(complement) BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(address_of) BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(logical_not) BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(pre_inc) BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(pre_dec) BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(post_inc) BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(post_dec) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(shift_left) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(shift_right) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(multiplies) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(divides) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(modulus) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(plus) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(minus) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(less) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(greater) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(less_equal) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(greater_equal) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(equal_to) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(not_equal_to) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(logical_or) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(logical_and) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_or) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_and) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_xor) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(comma) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(mem_ptr) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(assign) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(shift_left_assign) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(shift_right_assign) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(multiplies_assign) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(divides_assign) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(modulus_assign) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(plus_assign) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(minus_assign) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_or_assign) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_and_assign) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_xor_assign) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(subscript) BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(member) #undef BOOST_PROTO_DEFINE_UNARY_METAFUNCTION #undef BOOST_PROTO_DEFINE_BINARY_METAFUNCTION #include <boost/proto/detail/traits.hpp> namespace functional { /// \brief A callable PolymorphicFunctionObject that is /// equivalent to the \c as_expr() function. template<typename Domain /* = default_domain*/> struct as_expr { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename T> struct result<This(T)> { typedef typename Domain::template as_expr<T>::result_type type; }; template<typename This, typename T> struct result<This(T &)> { typedef typename Domain::template as_expr<T>::result_type type; }; /// \brief Wrap an object in a Proto terminal if it isn't a /// Proto expression already. /// \param t The object to wrap. /// \return <tt>proto::as_expr\<Domain\>(t)</tt> template<typename T> BOOST_FORCEINLINE typename add_const<typename result<as_expr(T &)>::type>::type operator ()(T &t) const { return typename Domain::template as_expr<T>()(t); } /// \overload /// template<typename T> BOOST_FORCEINLINE typename add_const<typename result<as_expr(T const &)>::type>::type operator ()(T const &t) const { return typename Domain::template as_expr<T const>()(t); } #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) template<typename T, std::size_t N_> BOOST_FORCEINLINE typename add_const<typename result<as_expr(T (&)[N_])>::type>::type operator ()(T (&t)[N_]) const { return typename Domain::template as_expr<T[N_]>()(t); } template<typename T, std::size_t N_> BOOST_FORCEINLINE typename add_const<typename result<as_expr(T const (&)[N_])>::type>::type operator ()(T const (&t)[N_]) const { return typename Domain::template as_expr<T const[N_]>()(t); } #endif }; /// \brief A callable PolymorphicFunctionObject that is /// equivalent to the \c as_child() function. template<typename Domain /* = default_domain*/> struct as_child { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename T> struct result<This(T)> { typedef typename Domain::template as_child<T>::result_type type; }; template<typename This, typename T> struct result<This(T &)> { typedef typename Domain::template as_child<T>::result_type type; }; /// \brief Wrap an object in a Proto terminal if it isn't a /// Proto expression already. /// \param t The object to wrap. /// \return <tt>proto::as_child\<Domain\>(t)</tt> template<typename T> BOOST_FORCEINLINE typename add_const<typename result<as_child(T &)>::type>::type operator ()(T &t) const { return typename Domain::template as_child<T>()(t); } /// \overload /// template<typename T> BOOST_FORCEINLINE typename add_const<typename result<as_child(T const &)>::type>::type operator ()(T const &t) const { return typename Domain::template as_child<T const>()(t); } }; /// \brief A callable PolymorphicFunctionObject that is /// equivalent to the \c child_c() function. template<long N> struct child_c { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Expr> struct result<This(Expr)> { typedef typename result_of::child_c<Expr, N>::type type; }; /// \brief Return the Nth child of the given expression. /// \param expr The expression node. /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true /// \pre <tt>N \< Expr::proto_arity::value</tt> /// \return <tt>proto::child_c\<N\>(expr)</tt> /// \throw nothrow template<typename Expr> BOOST_FORCEINLINE typename result_of::child_c<Expr &, N>::type operator ()(Expr &e) const { return result_of::child_c<Expr &, N>::call(e); } /// \overload /// template<typename Expr> BOOST_FORCEINLINE typename result_of::child_c<Expr const &, N>::type operator ()(Expr const &e) const { return result_of::child_c<Expr const &, N>::call(e); } }; /// \brief A callable PolymorphicFunctionObject that is /// equivalent to the \c child() function. /// /// A callable PolymorphicFunctionObject that is /// equivalent to the \c child() function. \c N is required /// to be an MPL Integral Constant. template<typename N /* = mpl::long_<0>*/> struct child { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Expr> struct result<This(Expr)> { typedef typename result_of::child<Expr, N>::type type; }; /// \brief Return the Nth child of the given expression. /// \param expr The expression node. /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true /// \pre <tt>N::value \< Expr::proto_arity::value</tt> /// \return <tt>proto::child\<N\>(expr)</tt> /// \throw nothrow template<typename Expr> BOOST_FORCEINLINE typename result_of::child<Expr &, N>::type operator ()(Expr &e) const { return result_of::child<Expr &, N>::call(e); } /// \overload /// template<typename Expr> BOOST_FORCEINLINE typename result_of::child<Expr const &, N>::type operator ()(Expr const &e) const { return result_of::child<Expr const &, N>::call(e); } }; /// \brief A callable PolymorphicFunctionObject that is /// equivalent to the \c value() function. struct value { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Expr> struct result<This(Expr)> { typedef typename result_of::value<Expr>::type type; }; /// \brief Return the value of the given terminal expression. /// \param expr The terminal expression node. /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true /// \pre <tt>0 == Expr::proto_arity::value</tt> /// \return <tt>proto::value(expr)</tt> /// \throw nothrow template<typename Expr> BOOST_FORCEINLINE typename result_of::value<Expr &>::type operator ()(Expr &e) const { return e.proto_base().child0; } /// \overload /// template<typename Expr> BOOST_FORCEINLINE typename result_of::value<Expr const &>::type operator ()(Expr const &e) const { return e.proto_base().child0; } }; /// \brief A callable PolymorphicFunctionObject that is /// equivalent to the \c left() function. struct left { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Expr> struct result<This(Expr)> { typedef typename result_of::left<Expr>::type type; }; /// \brief Return the left child of the given binary expression. /// \param expr The expression node. /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true /// \pre <tt>2 == Expr::proto_arity::value</tt> /// \return <tt>proto::left(expr)</tt> /// \throw nothrow template<typename Expr> BOOST_FORCEINLINE typename result_of::left<Expr &>::type operator ()(Expr &e) const { return e.proto_base().child0; } /// \overload /// template<typename Expr> BOOST_FORCEINLINE typename result_of::left<Expr const &>::type operator ()(Expr const &e) const { return e.proto_base().child0; } }; /// \brief A callable PolymorphicFunctionObject that is /// equivalent to the \c right() function. struct right { BOOST_PROTO_CALLABLE() template<typename Sig> struct result; template<typename This, typename Expr> struct result<This(Expr)> { typedef typename result_of::right<Expr>::type type; }; /// \brief Return the right child of the given binary expression. /// \param expr The expression node. /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true /// \pre <tt>2 == Expr::proto_arity::value</tt> /// \return <tt>proto::right(expr)</tt> /// \throw nothrow template<typename Expr> BOOST_FORCEINLINE typename result_of::right<Expr &>::type operator ()(Expr &e) const { return e.proto_base().child1; } template<typename Expr> BOOST_FORCEINLINE typename result_of::right<Expr const &>::type operator ()(Expr const &e) const { return e.proto_base().child1; } }; } /// \brief A function that wraps non-Proto expression types in Proto /// terminals and leaves Proto expression types alone. /// /// The <tt>as_expr()</tt> function turns objects into Proto terminals if /// they are not Proto expression types already. Non-Proto types are /// held by value, if possible. Types which are already Proto types are /// left alone and returned by reference. /// /// This function can be called either with an explicitly specified /// \c Domain parameter (i.e., <tt>as_expr\<Domain\>(t)</tt>), or /// without (i.e., <tt>as_expr(t)</tt>). If no domain is /// specified, \c default_domain is assumed. /// /// If <tt>is_expr\<T\>::value</tt> is \c true, then the argument is /// returned unmodified, by reference. Otherwise, the argument is wrapped /// in a Proto terminal expression node according to the following rules. /// If \c T is a function type, let \c A be <tt>T &</tt>. Otherwise, let /// \c A be the type \c T stripped of cv-qualifiers. Then, \c as_expr() /// returns <tt>Domain()(terminal\<A\>::type::make(t))</tt>. /// /// \param t The object to wrap. template<typename T> BOOST_FORCEINLINE typename add_const<typename result_of::as_expr<T, default_domain>::type>::type as_expr(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T) BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)) { return default_domain::as_expr<T>()(t); } /// \overload /// template<typename T> BOOST_FORCEINLINE typename add_const<typename result_of::as_expr<T const, default_domain>::type>::type as_expr(T const &t) { return default_domain::as_expr<T const>()(t); } /// \overload /// template<typename Domain, typename T> BOOST_FORCEINLINE typename add_const<typename result_of::as_expr<T, Domain>::type>::type as_expr(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T) BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)) { return typename Domain::template as_expr<T>()(t); } /// \overload /// template<typename Domain, typename T> BOOST_FORCEINLINE typename add_const<typename result_of::as_expr<T const, Domain>::type>::type as_expr(T const &t) { return typename Domain::template as_expr<T const>()(t); } /// \brief A function that wraps non-Proto expression types in Proto /// terminals (by reference) and returns Proto expression types by /// reference /// /// The <tt>as_child()</tt> function turns objects into Proto terminals if /// they are not Proto expression types already. Non-Proto types are /// held by reference. Types which are already Proto types are simply /// returned as-is. /// /// This function can be called either with an explicitly specified /// \c Domain parameter (i.e., <tt>as_child\<Domain\>(t)</tt>), or /// without (i.e., <tt>as_child(t)</tt>). If no domain is /// specified, \c default_domain is assumed. /// /// If <tt>is_expr\<T\>::value</tt> is \c true, then the argument is /// returned as-is. Otherwise, \c as_child() returns /// <tt>Domain()(terminal\<T &\>::type::make(t))</tt>. /// /// \param t The object to wrap. template<typename T> BOOST_FORCEINLINE typename add_const<typename result_of::as_child<T, default_domain>::type>::type as_child(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T) BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)) { return default_domain::as_child<T>()(t); } /// \overload /// template<typename T> BOOST_FORCEINLINE typename add_const<typename result_of::as_child<T const, default_domain>::type>::type as_child(T const &t) { return default_domain::as_child<T const>()(t); } /// \overload /// template<typename Domain, typename T> BOOST_FORCEINLINE typename add_const<typename result_of::as_child<T, Domain>::type>::type as_child(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T) BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)) { return typename Domain::template as_child<T>()(t); } /// \overload /// template<typename Domain, typename T> BOOST_FORCEINLINE typename add_const<typename result_of::as_child<T const, Domain>::type>::type as_child(T const &t) { return typename Domain::template as_child<T const>()(t); } /// \brief Return the Nth child of the specified Proto expression. /// /// Return the Nth child of the specified Proto expression. If /// \c N is not specified, as in \c child(expr), then \c N is assumed /// to be <tt>mpl::long_\<0\></tt>. The child is returned by /// reference. /// /// \param expr The Proto expression. /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true. /// \pre \c N is an MPL Integral Constant. /// \pre <tt>N::value \< Expr::proto_arity::value</tt> /// \throw nothrow /// \return A reference to the Nth child template<typename N, typename Expr> BOOST_FORCEINLINE typename result_of::child<Expr &, N>::type child(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr)) { return result_of::child<Expr &, N>::call(e); } /// \overload /// template<typename N, typename Expr> BOOST_FORCEINLINE typename result_of::child<Expr const &, N>::type child(Expr const &e) { return result_of::child<Expr const &, N>::call(e); } /// \overload /// template<typename Expr2> BOOST_FORCEINLINE typename detail::expr_traits<typename Expr2::proto_base_expr::proto_child0>::reference child(Expr2 &expr2 BOOST_PROTO_DISABLE_IF_IS_CONST(Expr2)) { return expr2.proto_base().child0; } /// \overload /// template<typename Expr2> BOOST_FORCEINLINE typename detail::expr_traits<typename Expr2::proto_base_expr::proto_child0>::const_reference child(Expr2 const &expr2) { return expr2.proto_base().child0; } /// \brief Return the Nth child of the specified Proto expression. /// /// Return the Nth child of the specified Proto expression. The child /// is returned by reference. /// /// \param expr The Proto expression. /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true. /// \pre <tt>N \< Expr::proto_arity::value</tt> /// \throw nothrow /// \return A reference to the Nth child template<long N, typename Expr> BOOST_FORCEINLINE typename result_of::child_c<Expr &, N>::type child_c(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr)) { return result_of::child_c<Expr &, N>::call(e); } /// \overload /// template<long N, typename Expr> BOOST_FORCEINLINE typename result_of::child_c<Expr const &, N>::type child_c(Expr const &e) { return result_of::child_c<Expr const &, N>::call(e); } /// \brief Return the value stored within the specified Proto /// terminal expression. /// /// Return the value stored within the specified Proto /// terminal expression. The value is returned by /// reference. /// /// \param expr The Proto terminal expression. /// \pre <tt>N::value == 0</tt> /// \throw nothrow /// \return A reference to the terminal's value template<typename Expr> BOOST_FORCEINLINE typename result_of::value<Expr &>::type value(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr)) { return e.proto_base().child0; } /// \overload /// template<typename Expr> BOOST_FORCEINLINE typename result_of::value<Expr const &>::type value(Expr const &e) { return e.proto_base().child0; } /// \brief Return the left child of the specified binary Proto /// expression. /// /// Return the left child of the specified binary Proto expression. The /// child is returned by reference. /// /// \param expr The Proto expression. /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true. /// \pre <tt>2 == Expr::proto_arity::value</tt> /// \throw nothrow /// \return A reference to the left child template<typename Expr> BOOST_FORCEINLINE typename result_of::left<Expr &>::type left(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr)) { return e.proto_base().child0; } /// \overload /// template<typename Expr> BOOST_FORCEINLINE typename result_of::left<Expr const &>::type left(Expr const &e) { return e.proto_base().child0; } /// \brief Return the right child of the specified binary Proto /// expression. /// /// Return the right child of the specified binary Proto expression. The /// child is returned by reference. /// /// \param expr The Proto expression. /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true. /// \pre <tt>2 == Expr::proto_arity::value</tt> /// \throw nothrow /// \return A reference to the right child template<typename Expr> BOOST_FORCEINLINE typename result_of::right<Expr &>::type right(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr)) { return e.proto_base().child1; } /// \overload /// template<typename Expr> BOOST_FORCEINLINE typename result_of::right<Expr const &>::type right(Expr const &e) { return e.proto_base().child1; } /// INTERNAL ONLY /// template<typename Domain> struct is_callable<functional::as_expr<Domain> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename Domain> struct is_callable<functional::as_child<Domain> > : mpl::true_ {}; /// INTERNAL ONLY /// template<long N> struct is_callable<functional::child_c<N> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename N> struct is_callable<functional::child<N> > : mpl::true_ {}; }} #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[ �^`- `- domain.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file domain.hpp /// Contains definition of domain\<\> class template and helpers for /// defining domains with a generator and a grammar for controlling /// operator overloading. // // Copyright 2008 Eric Niebler. 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_PROTO_DOMAIN_HPP_EAN_02_13_2007 #define BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007 #include <boost/ref.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/generate.hpp> #include <boost/proto/detail/as_expr.hpp> #include <boost/proto/detail/deduce_domain.hpp> #if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { struct not_a_generator {}; struct not_a_grammar {}; struct not_a_domain {}; } namespace domainns_ { /// \brief For use in defining domain tags to be used /// with \c proto::extends\<\>. A \e Domain associates /// an expression type with a \e Generator, and optionally /// a \e Grammar. /// /// The Generator determines how new expressions in the /// domain are constructed. Typically, a generator wraps /// all new expressions in a wrapper that imparts /// domain-specific behaviors to expressions within its /// domain. (See \c proto::extends\<\>.) /// /// The Grammar determines whether a given expression is /// valid within the domain, and automatically disables /// any operator overloads which would cause an invalid /// expression to be created. By default, the Grammar /// parameter defaults to the wildcard, \c proto::_, which /// makes all expressions valid within the domain. /// /// The Super declares the domain currently being defined /// to be a sub-domain of Super. Expressions in sub-domains /// can be freely combined with expressions in its super- /// domain (and <I>its</I> super-domain, etc.). /// /// Example: /// \code /// template<typename Expr> /// struct MyExpr; /// /// struct MyGrammar /// : or_< terminal<_>, plus<MyGrammar, MyGrammar> > /// {}; /// /// // Define MyDomain, in which all expressions are /// // wrapped in MyExpr<> and only expressions that /// // conform to MyGrammar are allowed. /// struct MyDomain /// : domain<generator<MyExpr>, MyGrammar> /// {}; /// /// // Use MyDomain to define MyExpr /// template<typename Expr> /// struct MyExpr /// : extends<Expr, MyExpr<Expr>, MyDomain> /// { /// // ... /// }; /// \endcode /// template< typename Generator // = default_generator , typename Grammar // = proto::_ , typename Super // = no_super_domain > struct domain : Generator { typedef Generator proto_generator; typedef Grammar proto_grammar; typedef Super proto_super_domain; typedef domain proto_base_domain; /// INTERNAL ONLY typedef void proto_is_domain_; /// \brief A unary MonomorphicFunctionObject that turns objects into Proto /// expression objects in this domain. /// /// The <tt>as_expr\<\></tt> function object turns objects into Proto expressions, if /// they are not already, by making them Proto terminals held by value if /// possible. Objects that are already Proto expressions are left alone. /// /// If <tt>wants_basic_expr\<Generator\>::value</tt> is true, then let \c E be \c basic_expr; /// otherwise, let \t E be \c expr. Given an lvalue \c t of type \c T: /// /// If \c T is not a Proto expression type the resulting terminal is /// calculated as follows: /// /// If \c T is a function type, an abstract type, or a type derived from /// \c std::ios_base, let \c A be <tt>T &</tt>. /// Otherwise, let \c A be the type \c T stripped of cv-qualifiers. /// Then, the result of applying <tt>as_expr\<T\>()(t)</tt> is /// <tt>Generator()(E\<tag::terminal, term\<A\> \>::make(t))</tt>. /// /// If \c T is a Proto expression type and its generator type is different from /// \c Generator, the result is <tt>Generator()(t)</tt>. /// /// Otherwise, the result is \c t converted to an (un-const) rvalue. /// template<typename T, typename IsExpr = void, typename Callable = proto::callable> struct as_expr : detail::as_expr< T , typename detail::base_generator<Generator>::type , wants_basic_expr<Generator>::value > { BOOST_PROTO_CALLABLE() }; /// INTERNAL ONLY /// template<typename T> struct as_expr<T, typename T::proto_is_expr_, proto::callable> { BOOST_PROTO_CALLABLE() typedef typename remove_const<T>::type result_type; BOOST_FORCEINLINE result_type operator()(T &e) const { return e; } }; /// \brief A unary MonomorphicFunctionObject that turns objects into Proto /// expression objects in this domain. /// /// The <tt>as_child\<\></tt> function object turns objects into Proto expressions, if /// they are not already, by making them Proto terminals held by reference. /// Objects that are already Proto expressions are simply returned by reference. /// /// If <tt>wants_basic_expr\<Generator\>::value</tt> is true, then let \c E be \c basic_expr; /// otherwise, let \t E be \c expr. Given an lvalue \c t of type \c T: /// /// If \c T is not a Proto expression type the resulting terminal is /// <tt>Generator()(E\<tag::terminal, term\<T &\> \>::make(t))</tt>. /// /// If \c T is a Proto expression type and its generator type is different from /// \c Generator, the result is <tt>Generator()(t)</tt>. /// /// Otherwise, the result is the lvalue \c t. /// template<typename T, typename IsExpr = void, typename Callable = proto::callable> struct as_child : detail::as_child< T , typename detail::base_generator<Generator>::type , wants_basic_expr<Generator>::value > { BOOST_PROTO_CALLABLE() }; /// INTERNAL ONLY /// template<typename T> struct as_child<T, typename T::proto_is_expr_, proto::callable> { BOOST_PROTO_CALLABLE() typedef T &result_type; BOOST_FORCEINLINE result_type operator()(T &e) const { return e; } }; }; /// \brief The domain expressions have by default, if /// \c proto::extends\<\> has not been used to associate /// a domain with an expression. /// struct default_domain : domain<> {}; /// \brief A domain to use when you prefer the use of /// \c proto::basic_expr\<\> over \c proto::expr\<\>. /// struct basic_default_domain : domain<basic_default_generator> {}; /// \brief A pseudo-domain for use in functions and /// metafunctions that require a domain parameter. It /// indicates that the domain of the parent node should /// be inferred from the domains of the child nodes. /// /// \attention \c deduce_domain is not itself a valid domain. /// struct deduce_domain : domain<detail::not_a_generator, detail::not_a_grammar, detail::not_a_domain> {}; /// \brief Given a domain, a tag type and an argument list, /// compute the type of the expression to generate. This is /// either an instance of \c proto::expr\<\> or /// \c proto::basic_expr\<\>. /// template<typename Domain, typename Tag, typename Args, bool WantsBasicExpr> struct base_expr { typedef proto::expr<Tag, Args, Args::arity> type; }; /// INTERNAL ONLY /// template<typename Domain, typename Tag, typename Args> struct base_expr<Domain, Tag, Args, true> { typedef proto::basic_expr<Tag, Args, Args::arity> type; }; } /// A metafunction that returns \c mpl::true_ /// if the type \c T is the type of a Proto domain; /// \c mpl::false_ otherwise. If \c T inherits from /// \c proto::domain\<\>, \c is_domain\<T\> is /// \c mpl::true_. template<typename T, typename Void /* = void*/> struct is_domain : mpl::false_ {}; /// INTERNAL ONLY /// template<typename T> struct is_domain<T, typename T::proto_is_domain_> : mpl::true_ {}; /// A metafunction that returns the domain of /// a given type. If \c T is a Proto expression /// type, it returns that expression's associated /// domain. If not, it returns /// \c proto::default_domain. template<typename T, typename Void /* = void*/> struct domain_of { typedef default_domain type; }; /// INTERNAL ONLY /// template<typename T> struct domain_of<T, typename T::proto_is_expr_> { typedef typename T::proto_domain type; }; /// INTERNAL ONLY /// template<typename T> struct domain_of<T &, void> { typedef typename domain_of<T>::type type; }; /// INTERNAL ONLY /// template<typename T> struct domain_of<boost::reference_wrapper<T>, void> { typedef typename domain_of<T>::type type; }; /// INTERNAL ONLY /// template<typename T> struct domain_of<boost::reference_wrapper<T> const, void> { typedef typename domain_of<T>::type type; }; /// A metafunction that returns \c mpl::true_ /// if the type \c SubDomain is a sub-domain of /// \c SuperDomain; \c mpl::false_ otherwise. template<typename SubDomain, typename SuperDomain> struct is_sub_domain_of : is_sub_domain_of<typename SubDomain::proto_super_domain, SuperDomain> {}; /// INTERNAL ONLY /// template<typename SuperDomain> struct is_sub_domain_of<proto::no_super_domain, SuperDomain> : mpl::false_ {}; /// INTERNAL ONLY /// template<typename SuperDomain> struct is_sub_domain_of<SuperDomain, SuperDomain> : mpl::true_ {}; }} #if defined(_MSC_VER) # pragma warning(pop) #endif #endif PK �J�[ez=Ϩ � literal.hppnu �[��� /////////////////////////////////////////////////////////////////////////////// /// \file literal.hpp /// The literal\<\> terminal wrapper, and the proto::lit() function for /// creating literal\<\> wrappers. // // Copyright 2008 Eric Niebler. 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_PROTO_LITERAL_HPP_EAN_01_03_2007 #define BOOST_PROTO_LITERAL_HPP_EAN_01_03_2007 #include <boost/config.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/expr.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/extends.hpp> namespace boost { namespace proto { namespace utility { /// \brief A simple wrapper for a terminal, provided for /// ease of use. /// /// A simple wrapper for a terminal, provided for /// ease of use. In all cases, <tt>literal\<X\> l(x);</tt> /// is equivalent to <tt>terminal\<X\>::type l = {x};</tt>. /// /// The \c Domain template parameter defaults to /// \c proto::default_domain. template< typename T , typename Domain // = default_domain > struct literal : extends<basic_expr<tag::terminal, term<T>, 0>, literal<T, Domain>, Domain> { private: typedef basic_expr<tag::terminal, term<T>, 0> terminal_type; typedef extends<terminal_type, literal<T, Domain>, Domain> base_type; typedef literal<T, Domain> literal_t; public: typedef typename detail::term_traits<T>::value_type value_type; typedef typename detail::term_traits<T>::reference reference; typedef typename detail::term_traits<T>::const_reference const_reference; literal() : base_type(terminal_type::make(T())) {} #ifndef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS literal(literal const &) = default; #endif template<typename U> literal(U &u) : base_type(terminal_type::make(u)) {} template<typename U> literal(U const &u) : base_type(terminal_type::make(u)) {} template<typename U> literal(literal<U, Domain> const &u) : base_type(terminal_type::make(u.get())) {} BOOST_PROTO_EXTENDS_USING_ASSIGN(literal_t) reference get() { return proto::value(*this); } const_reference get() const { return proto::value(*this); } }; } /// \brief A helper function for creating a \c literal\<\> wrapper. /// \param t The object to wrap. /// \return literal\<T &\>(t) /// \attention The returned value holds the argument by reference. /// \throw nothrow template<typename T> inline literal<T &> const lit(T &t) { return literal<T &>(t); } /// \overload /// template<typename T> inline literal<T const &> const lit(T const &t) { #ifdef BOOST_MSVC #pragma warning(push) #pragma warning(disable: 4180) // warning C4180: qualifier applied to function type has no meaning; ignored #endif return literal<T const &>(t); #ifdef BOOST_MSVC #pragma warning(pop) #endif } }} #endif PK �J�[X�6�x, x, repeat.hppnu �[��� PK �J�[�W��� � �, proto_typeof.hppnu �[��� PK �J�[��� �D core.hppnu �[��� PK �J�[��V}7� 7� I extends.hppnu �[��� PK �J�[Z!^x x �� tags.hppnu �[��� PK �J�[�ʗ�@ @ 7 functional.hppnu �[��� PK �J�[���� � � transform.hppnu �[��� PK �J�[6�u�8 �8 � generate.hppnu �[��� PK �J�[B�6��r �r gA proto_fwd.hppnu �[��� PK �J�[֧�� m� functional/range.hppnu �[��� PK �J�[E~qq q �� functional/range/begin.hppnu �[��� PK �J�[��'� � r� functional/range/rbegin.hppnu �[��� PK �J�[�L�U} } W� functional/range/empty.hppnu �[��� PK �J�[�h��_ _ � functional/range/end.hppnu �[��� PK �J�[��a� � �� functional/range/size.hppnu �[��� PK �J�[Gy�� � �� functional/range/rend.hppnu �[��� PK �J�[[�� � �� functional/fusion/push_front.hppnu �[��� PK �J�[���;� � �� functional/fusion/push_back.hppnu �[��� PK �J�[?;�;� � �� functional/fusion/pop_front.hppnu �[��� PK �J�[�pꁁ � �� functional/fusion/reverse.hppnu �[��� PK �J�[��� � y� functional/fusion/pop_back.hppnu �[��� PK �J�[��8�, , a� functional/fusion/at.hppnu �[��� PK �J�[��LO O � functional/std/utility.hppnu �[��� PK �J�[��S] ] n functional/std/iterator.hppnu �[��� PK �J�[m�" ( functional/fusion.hppnu �[��� PK �J�[�� 4 4 w+ functional/std.hppnu �[��� PK �J�[�c:� � �- args.hppnu �[��� PK �J�[�� �� � �< matches.hppnu �[��� PK �J�[y���) �) � debug.hppnu �[��� PK �J�[�/I 6� deep_copy.hppnu �[��� PK �J�[ٜ��Q �Q � fusion.hppnu �[��� PK �J�[�[��L �L �V context/default.hppnu �[��� PK �J�[G �(+ + r� context/null.hppnu �[��� PK �J�[��`3�W �W - ݩ context/detail/preprocessed/callable_eval.hppnu �[��� PK �J�[_yf�S S , context/detail/preprocessed/default_eval.hppnu �[��� PK �J�[�!�� � ) }U context/detail/preprocessed/null_eval.hppnu �[��� PK �J�[Lk��� � ri context/detail/callable_eval.hppnu �[��� PK �J�[�A`}� � �y context/detail/default_eval.hppnu �[��� PK �J�[ - � � �� context/detail/null_eval.hppnu �[��� PK �J�[8%��.# .# � context/callable.hppnu �[��� PK �J�[y g �d �d Z� operators.hppnu �[��� PK �J�[ ��P P � context.hppnu �[��� PK �J�[f��6V V detail/and_n.hppnu �[��� PK �J�[�V= = �& detail/make_expr_funop.hppnu �[��� PK �J�[W�� � (/ detail/vararg_matches_impl.hppnu �[��� PK �J�[�)'� 8 detail/class_member_traits.hppnu �[��� PK �J�[2Ù�/= /= q? detail/preprocessed/and_n.hppnu �[��� PK �J�[IzG b# b# ' �| detail/preprocessed/make_expr_funop.hppnu �[��� PK �J�[�0=L� � + �� detail/preprocessed/vararg_matches_impl.hppnu �[��� PK �J�[dj�� � + �� detail/preprocessed/class_member_traits.hppnu �[��� PK �J�[sv��Q Q Y� detail/preprocessed/or_n.hppnu �[��� PK �J�[0l�RQW QW " �� detail/preprocessed/basic_expr.hppnu �[��� PK �J�[�O�h h + �B detail/preprocessed/extends_funop_const.hppnu �[��� PK �J�[���6 �6 + \^ detail/preprocessed/poly_function_funop.hppnu �[��� PK �J�[���{ { - r� detail/preprocessed/template_arity_helper.hppnu �[��� PK �J�[��6l l J� detail/preprocessed/args.hppnu �[��� PK �J�[9Ɯ�� � $ � detail/preprocessed/memfun_funop.hppnu �[��� PK �J�[��: �: �� detail/preprocessed/funop.hppnu �[��� PK �J�[�o�Ұ Ұ $ � detail/preprocessed/unpack_expr_.hppnu �[��� PK �J�[� ��>B >B ! � detail/preprocessed/deep_copy.hppnu �[��� PK �J�[#�{�. �. ! �� detail/preprocessed/make_expr.hppnu �[��� PK �J�[E�� & �' detail/preprocessed/lambda_matches.hppnu �[��� PK �J�[v�9/� /� &G detail/preprocessed/expr.hppnu �[��� PK �J�[��%��2 �2 , �* detail/preprocessed/poly_function_traits.hppnu �[��� PK �J�[4� ' �] detail/preprocessed/deduce_domain_n.hppnu �[��� PK �J�[xu��^� ^� ~ detail/preprocessed/matches_.hppnu �[��� PK �J�[�oR^;3 ;3 % � detail/preprocessed/extends_funop.hppnu �[��� PK �J�[(Y���� �� % KI detail/preprocessed/expr_variadic.hppnu �[��� PK �J�[�\���� �� l0 detail/preprocessed/traits.hppnu �[��� PK �J�[ �fH6U 6U " �� detail/preprocessed/make_expr_.hppnu �[��� PK �J�[���� K K ) %R detail/preprocessed/generate_by_value.hppnu �[��� PK �J�[fPa�� � ~� detail/or_n.hppnu �[��� PK �J�[�~�n n T� detail/basic_expr.hppnu �[��� PK �J�[Ͽ� � � detail/ignore_unused.hppnu �[��� PK �J�[%���B B �� detail/extends_funop_const.hppnu �[��� PK �J�[I��� � j� detail/poly_function_funop.hppnu �[��� PK �J�[=�8QA A �� detail/template_arity_helper.hppnu �[��� PK �J�[9&�� H� detail/args.hppnu �[��� PK �J�[�X�# # �� detail/memfun_funop.hppnu �[��� PK �J�[��B� � detail/funop.hppnu �[��� PK �J�[ _�� � V� detail/unpack_expr_.hppnu �[��� PK �J�[7�Z D D � detail/expr_funop.hppnu �[��� PK �J�[�b��� � "# detail/deduce_domain.hppnu �[��� PK �J�[0�o*� � > detail/deep_copy.hppnu �[��� PK �J�[��f�� � RJ detail/static_const.hppnu �[��� PK �J�[L�d� � �M detail/as_expr.hppnu �[��� PK �J�[4<�y �f detail/as_lvalue.hppnu �[��� PK �J�[�:� k detail/make_expr.hppnu �[��� PK �J�[#/�� ft detail/lambda_matches.hppnu �[��� PK �J�[լ�R R �} detail/dont_care.hppnu �[��� PK �J�[�@ e> e> P� detail/expr.hppnu �[��� PK �J�[UF�_�@ �@ � detail/decltype.hppnu �[��� PK �J�[�-y& " detail/poly_function_traits.hppnu �[��� PK �J�[ �� s detail/local.hppnu �[��� PK �J�[� �A A � detail/deduce_domain_n.hppnu �[��� PK �J�[��Ԏ� � > detail/remove_typename.hppnu �[��� PK �J�[��qD A/ detail/poly_function.hppnu �[��� PK �J�[�M�a �J detail/matches_.hppnu �[��� PK �J�[ن[S� � �Z detail/extends_funop.hppnu �[��� PK �J�[b�a�� � b detail/template_arity.hppnu �[��� PK �J�[�q�ќ � Qk detail/is_noncopyable.hppnu �[��� PK �J�[د �g# g# 6s detail/traits.hppnu �[��� PK �J�[0�Tcb b ޖ detail/make_expr_.hppnu �[��� PK �J�[s_Z�� � �� detail/generate_by_value.hppnu �[��� PK �J�[�>�ly= y= U� detail/deprecated.hppnu �[��� PK �J�[Č,5 5 � detail/any.hppnu �[��� PK �J�[=Z)�iK iK �� make_expr.hppnu �[��� PK �J�[� qB3 3 ,G expr.hppnu �[��� PK �J�[� �C� � �\ eval.hppnu �[��� PK �J�[�W�qE E mo proto.hppnu �[��� PK �J�[5[���% �% �q transform/make.hppnu �[��� PK �J�[��ү� � � transform/lazy.hppnu �[��� PK �J�[l�/�& �& G� transform/when.hppnu �[��� PK �J�[ ��*�M �M 8� transform/env.hppnu �[��� PK �J�[�ˀ/�& �& � transform/arg.hppnu �[��� PK �J�[�PTE1o 1o �; transform/default.hppnu �[��� PK �J�[� h0�T �T ^� transform/impl.hppnu �[��� PK �J�[��Zpu! u! E transform/fold.hppnu �[��� PK �J�[o ��� � �! transform/integral_c.hppnu �[��� PK �J�[�&��� � , transform/detail/make.hppnu �[��� PK �J�[cK`^� � K transform/detail/lazy.hppnu �[��� PK �J�[9�� � � 0W transform/detail/when.hppnu �[��� PK �J�[��Om� � * Fg transform/detail/default_function_impl.hppnu �[��� PK �J�[�B�'! ! & `u transform/detail/pass_through_impl.hppnu �[��� PK �J�[KǀX�� �� & ׆ transform/detail/preprocessed/make.hppnu �[��� PK �J�[5�)�3 �3 & �q transform/detail/preprocessed/lazy.hppnu �[��� PK �J�[T�d�K K & � transform/detail/preprocessed/when.hppnu �[��� PK �J�[Q=�s@q @q 7 �� transform/detail/preprocessed/default_function_impl.hppnu �[��� PK �J�[��k� q q 3 V8 transform/detail/preprocessed/pass_through_impl.hppnu �[��� PK �J�[��N�] ] + ĩ transform/detail/preprocessed/pack_impl.hppnu �[��� PK �J�[��ٵ 1 % transform/detail/preprocessed/construct_funop.hppnu �[��� PK �J�[�� #�" �" - � transform/detail/preprocessed/expand_pack.hppnu �[��� PK �J�[��p�� �� + �5 transform/detail/preprocessed/fold_impl.hppnu �[��� PK �J�[rvj�� � 5 �� transform/detail/preprocessed/construct_pod_funop.hppnu �[��� PK �J�[-���S �S & � transform/detail/preprocessed/call.hppnu �[��� PK �J�[E�Y q q 5 KG transform/detail/preprocessed/make_gcc_workaround.hppnu �[��� PK �J�[9�'D D ʸ transform/detail/pack.hppnu �[��� PK �J�[6� � � W� transform/detail/pack_impl.hppnu �[��� PK �J�[�]��� � $ �� transform/detail/construct_funop.hppnu �[��� PK �J�[ϕ�Q �� transform/detail/expand_pack.hppnu �[��� PK �J�[xhB]� � � transform/detail/fold_impl.hppnu �[��� PK �J�[`��g� � ( 0� transform/detail/construct_pod_funop.hppnu �[��� PK �J�[�)� � q transform/detail/call.hppnu �[��� PK �J�['[�d d ( { transform/detail/make_gcc_workaround.hppnu �[��� PK �J�[ۏ�d? d? 7& transform/call.hppnu �[��� PK �J�[!Ԉl^ ^ �e transform/fold_tree.hppnu �[��� PK �J�[ S�T� � � transform/pass_through.hppnu �[��� PK �J�[Y��(r� r� �� traits.hppnu �[��� PK �J�[ �^`- `- CG domain.hppnu �[��� PK �J�[ez=Ϩ � �t literal.hppnu �[��� PK � � �4 ��
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0.04 |
proxy
|
phpinfo
|
???????????