diff options
Diffstat (limited to '3rdParty/Boost/src/boost/proto/make_expr.hpp')
-rw-r--r-- | 3rdParty/Boost/src/boost/proto/make_expr.hpp | 821 |
1 files changed, 821 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/proto/make_expr.hpp b/3rdParty/Boost/src/boost/proto/make_expr.hpp new file mode 100644 index 0000000..75b42ba --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/make_expr.hpp @@ -0,0 +1,821 @@ +#ifndef BOOST_PP_IS_ITERATING + /////////////////////////////////////////////////////////////////////////////// + /// \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/config.hpp> + #include <boost/detail/workaround.hpp> + #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/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> + + #ifdef _MSC_VER + # pragma warning(push) + # pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored + #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)) \ + /**/ + + /// 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)) \ + /**/ + + 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> + {}; + + 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; + + 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 + 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; + + 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 \ + (4, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/make_expr.hpp>, 1)) \ + /**/ + + #include BOOST_PP_ITERATE() + } + + 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> + 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 ... + + #define BOOST_PP_ITERATION_PARAMS_1 \ + (4, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/make_expr.hpp>, 2)) \ + /**/ + + #include BOOST_PP_ITERATE() + + /// 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> + 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> + 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> + 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... + + #define BOOST_PP_ITERATION_PARAMS_1 \ + (4, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/make_expr.hpp>, 3)) \ + /**/ + + #include BOOST_PP_ITERATE() + + /// \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> + 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> + 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_ + {}; + + }} + + #ifdef _MSC_VER + # pragma warning(pop) + #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 + + #endif // BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005 + +#elif BOOST_PP_ITERATION_FLAGS() == 1 + + #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; + + 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) + > + {}; + + 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; + + 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; + + static type const call(Sequence const &sequence) + { + return other::call(sequence); + } + }; + + #undef N + #undef M + +#elif BOOST_PP_ITERATION_FLAGS() == 2 + + #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)> + 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 + +#elif BOOST_PP_ITERATION_FLAGS() == 3 + + #define N BOOST_PP_ITERATION() + + /// \overload + /// + template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + 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)> + 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 // BOOST_PP_IS_ITERATING |