1148 lines
45 KiB
C++
1148 lines
45 KiB
C++
#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/proto/detail/prefix.hpp>
|
|
#include <boost/version.hpp>
|
|
#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_shifted_binary_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/is_same.hpp>
|
|
#include <boost/type_traits/add_const.hpp>
|
|
#include <boost/type_traits/add_reference.hpp>
|
|
#include <boost/type_traits/remove_cv.hpp>
|
|
#include <boost/type_traits/remove_const.hpp>
|
|
#include <boost/type_traits/remove_reference.hpp>
|
|
#include <boost/proto/proto_fwd.hpp>
|
|
#include <boost/proto/traits.hpp>
|
|
#include <boost/proto/domain.hpp>
|
|
#include <boost/proto/generate.hpp>
|
|
#if BOOST_VERSION >= 103500
|
|
# 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>
|
|
#else
|
|
# include <boost/spirit/fusion/sequence/begin.hpp>
|
|
# include <boost/spirit/fusion/iterator/next.hpp>
|
|
# include <boost/spirit/fusion/iterator/value_of.hpp>
|
|
# include <boost/spirit/fusion/sequence/size.hpp>
|
|
#endif
|
|
#include <boost/proto/detail/poly_function.hpp>
|
|
#include <boost/proto/detail/deprecated.hpp>
|
|
#include <boost/proto/detail/suffix.hpp>
|
|
|
|
#ifdef _MSC_VER
|
|
# pragma warning(push)
|
|
# pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored
|
|
#endif
|
|
|
|
namespace boost
|
|
{
|
|
/// INTERNAL ONLY
|
|
///
|
|
namespace fusion
|
|
{
|
|
/// INTERNAL ONLY
|
|
///
|
|
template<typename Function>
|
|
class unfused_generic;
|
|
}
|
|
}
|
|
|
|
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) \
|
|
>::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) \
|
|
>::call(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::BOOST_PROTO_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::BOOST_PROTO_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::BOOST_PROTO_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 \
|
|
>::type \
|
|
/**/
|
|
|
|
/// INTERNAL ONLY
|
|
///
|
|
#define BOOST_PROTO_FUSION_AS_CHILD_AT(Z, N, DATA) \
|
|
detail::protoify_< \
|
|
BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \
|
|
, Domain \
|
|
>::call(BOOST_PROTO_FUSION_AT(Z, N, DATA)) \
|
|
/**/
|
|
|
|
namespace detail
|
|
{
|
|
template<typename T, typename Domain>
|
|
struct protoify_
|
|
{
|
|
typedef
|
|
typename boost::unwrap_reference<T>::type
|
|
unref_type;
|
|
|
|
typedef
|
|
typename mpl::eval_if<
|
|
boost::is_reference_wrapper<T>
|
|
, proto::result_of::as_child<unref_type, Domain>
|
|
, proto::result_of::as_expr<unref_type, Domain>
|
|
>::type
|
|
type;
|
|
|
|
static type call(T &t)
|
|
{
|
|
return typename mpl::if_<
|
|
is_reference_wrapper<T>
|
|
, functional::as_child<Domain>
|
|
, functional::as_expr<Domain>
|
|
>::type()(static_cast<unref_type &>(t));
|
|
}
|
|
};
|
|
|
|
template<typename T, typename Domain>
|
|
struct protoify_<T &, Domain>
|
|
{
|
|
typedef
|
|
typename proto::result_of::as_child<T, Domain>::type
|
|
type;
|
|
|
|
static type call(T &t)
|
|
{
|
|
return functional::as_child<Domain>()(t);
|
|
}
|
|
};
|
|
|
|
template<
|
|
int Index
|
|
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(
|
|
BOOST_PROTO_MAX_ARITY
|
|
, typename D
|
|
, = void BOOST_PP_INTERCEPT
|
|
)
|
|
>
|
|
struct select_nth
|
|
{
|
|
BOOST_MPL_ASSERT_MSG((false), PROTO_DOMAIN_MISMATCH, (select_nth));
|
|
typedef default_domain type;
|
|
};
|
|
|
|
template<typename Void = void>
|
|
struct deduce_domain0
|
|
{
|
|
typedef default_domain type;
|
|
};
|
|
|
|
template<int I>
|
|
struct sized
|
|
{
|
|
char buffer[I];
|
|
};
|
|
|
|
template<typename T>
|
|
struct nondeduced_domain
|
|
{
|
|
typedef nondeduced_domain type;
|
|
nondeduced_domain(T);
|
|
nondeduced_domain(default_domain);
|
|
};
|
|
|
|
template<>
|
|
struct nondeduced_domain<default_domain>
|
|
{
|
|
typedef nondeduced_domain type;
|
|
nondeduced_domain(default_domain);
|
|
};
|
|
|
|
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::BOOST_PROTO_FUSION_RESULT_OF::value_of<
|
|
typename fusion::BOOST_PROTO_FUSION_RESULT_OF::begin<Sequence>::type
|
|
>::type
|
|
>::type
|
|
terminal_type;
|
|
|
|
typedef
|
|
typename proto::detail::protoify_<
|
|
terminal_type
|
|
, Domain
|
|
>::type
|
|
type;
|
|
|
|
static type const call(Sequence const &sequence)
|
|
{
|
|
return proto::detail::protoify_<terminal_type, Domain>::call(fusion::BOOST_PROTO_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>::type result_type;
|
|
|
|
result_type operator()(typename add_reference<A>::type a) const
|
|
{
|
|
return proto::detail::protoify_<A, Domain>::call(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>
|
|
{};
|
|
|
|
template<typename Base, typename Expr>
|
|
Expr implicit_expr_wrap(Base const &expr, mpl::false_, Expr *)
|
|
{
|
|
return Expr(expr);
|
|
}
|
|
|
|
template<typename Base, typename Expr>
|
|
Expr implicit_expr_wrap(Base const &expr, mpl::true_, Expr *)
|
|
{
|
|
Expr that = {expr};
|
|
return that;
|
|
}
|
|
|
|
template<typename A0, typename Void = void>
|
|
struct implicit_expr_1
|
|
{
|
|
A0 &a0;
|
|
|
|
template<typename Args>
|
|
operator proto::expr<tag::terminal, Args, 0>() const
|
|
{
|
|
proto::expr<tag::terminal, Args, 0> that = {this->a0};
|
|
return that;
|
|
}
|
|
|
|
template<typename Expr>
|
|
operator Expr() const
|
|
{
|
|
typename Expr::proto_base_expr that = *this;
|
|
return detail::implicit_expr_wrap(that, is_aggregate<Expr>(), static_cast<Expr *>(0));
|
|
}
|
|
};
|
|
|
|
template<typename A0>
|
|
struct implicit_expr_1<A0, typename A0::proto_is_expr_>
|
|
{
|
|
A0 &a0;
|
|
|
|
#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, BOOST_TESTED_AT(1010))
|
|
typedef typename remove_cv<A0>::type uncv_a0_type;
|
|
|
|
operator uncv_a0_type &() const
|
|
{
|
|
return const_cast<uncv_a0_type &>(this->a0);
|
|
}
|
|
#else
|
|
operator A0 &() const
|
|
{
|
|
return this->a0;
|
|
}
|
|
#endif
|
|
|
|
template<typename Tag, typename Args>
|
|
operator proto::expr<Tag, Args, 1>() const
|
|
{
|
|
proto::expr<Tag, Args, 1> that = {this->a0};
|
|
return that;
|
|
}
|
|
|
|
template<typename Expr>
|
|
operator Expr() const
|
|
{
|
|
typename Expr::proto_base_expr that = *this;
|
|
return detail::implicit_expr_wrap(that, is_aggregate<Expr>(), static_cast<Expr *>(0));
|
|
}
|
|
};
|
|
|
|
#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
|
|
, typename A0
|
|
, BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS(
|
|
BOOST_PROTO_MAX_ARITY
|
|
, typename A
|
|
, BOOST_PROTO_WHEN_BUILDING_DOCS(= void) BOOST_PP_INTERCEPT
|
|
)
|
|
, typename Void1 BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
|
|
, typename Void2 BOOST_PROTO_WHEN_BUILDING_DOCS(= 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 BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
|
|
, typename Void2 BOOST_PROTO_WHEN_BUILDING_DOCS(= 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::BOOST_PROTO_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::BOOST_PROTO_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 BOOST_PROTO_WHEN_BUILDING_DOCS(= 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
|
|
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 BOOST_PROTO_WHEN_BUILDING_DOCS(= 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
|
|
operator ()(Sequence const &sequence) const
|
|
{
|
|
return proto::detail::unpack_expr_<
|
|
Tag
|
|
, Domain
|
|
, Sequence const
|
|
, fusion::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence>::type::value
|
|
>::call(sequence);
|
|
}
|
|
};
|
|
|
|
/// INTERNAL ONLY
|
|
///
|
|
template<typename Tag, typename Domain>
|
|
struct unfused_expr_fun
|
|
{
|
|
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;
|
|
};
|
|
|
|
template<typename Sequence>
|
|
typename proto::result_of::unpack_expr<Tag, Domain, Sequence const>::type
|
|
operator ()(Sequence const &sequence) const
|
|
{
|
|
return proto::detail::unpack_expr_<
|
|
Tag
|
|
, Domain
|
|
, Sequence const
|
|
, fusion::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence>::type::value
|
|
>::call(sequence);
|
|
}
|
|
};
|
|
|
|
/// INTERNAL ONLY
|
|
///
|
|
template<typename Tag, typename Domain>
|
|
struct unfused_expr
|
|
: fusion::unfused_generic<unfused_expr_fun<Tag, Domain> >
|
|
{
|
|
BOOST_PROTO_CALLABLE()
|
|
};
|
|
|
|
} // 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::BOOST_PROTO_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::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence2>::type::value
|
|
>::call(sequence2);
|
|
}
|
|
|
|
/// \brief Return a proxy object that holds its arguments by reference
|
|
/// and is implicitly convertible to an expression.
|
|
template<typename A0>
|
|
detail::implicit_expr_1<A0> const
|
|
implicit_expr(A0 &a0)
|
|
{
|
|
detail::implicit_expr_1<A0> that = {a0};
|
|
return that;
|
|
}
|
|
|
|
// Additional overloads generated by the preprocessor...
|
|
|
|
#define BOOST_PP_ITERATION_PARAMS_1 \
|
|
(4, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/make_expr.hpp>, 4)) \
|
|
/**/
|
|
|
|
#include BOOST_PP_ITERATE()
|
|
|
|
/// 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_
|
|
{};
|
|
|
|
/// INTERNAL ONLY
|
|
///
|
|
template<typename Tag, typename Domain>
|
|
struct is_callable<functional::unfused_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)
|
|
|
|
#if N > 1
|
|
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
|
|
struct BOOST_PP_CAT(implicit_expr_, N)
|
|
{
|
|
#define M0(Z, N, DATA) BOOST_PP_CAT(A, N) &BOOST_PP_CAT(a, N);
|
|
BOOST_PP_REPEAT(N, M0, ~)
|
|
#undef M0
|
|
|
|
template<typename Tag, typename Args>
|
|
operator proto::expr<Tag, Args, N>() const
|
|
{
|
|
#define M0(Z, N, DATA) \
|
|
implicit_expr_1<BOOST_PP_CAT(A, N)> BOOST_PP_CAT(b, N) \
|
|
= {this->BOOST_PP_CAT(a, N)}; \
|
|
typename Args::BOOST_PP_CAT(child, N) BOOST_PP_CAT(c, N) = BOOST_PP_CAT(b, N); \
|
|
/**/
|
|
BOOST_PP_REPEAT(N, M0, ~)
|
|
#undef M0
|
|
proto::expr<Tag, Args, N> that = {BOOST_PP_ENUM_PARAMS(N, c)};
|
|
return that;
|
|
}
|
|
|
|
template<typename Expr>
|
|
operator Expr() const
|
|
{
|
|
typename Expr::proto_base_expr that = *this;
|
|
return detail::implicit_expr_wrap(that, is_aggregate<Expr>(), static_cast<Expr *>(0));
|
|
}
|
|
};
|
|
#endif
|
|
|
|
template<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, typename T)>
|
|
struct select_nth<BOOST_PP_DEC(N), BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, T)>
|
|
{
|
|
typedef BOOST_PP_CAT(T, BOOST_PP_DEC(N)) type;
|
|
};
|
|
|
|
// Use function overloading as an efficient mechanism for
|
|
// calculating the domain shared by a bunch of proto expressions
|
|
// (or non-expressions, assumed to be in the default_domain).
|
|
// The domain of a set of domains S is deduced as follows:
|
|
// - If S contains only default_domain, the deduced domain is
|
|
// default_domain.
|
|
// - If S contains only X and default_domain, the deduced domain
|
|
// is X.
|
|
// - If S contains different domains X and Y, neither of which is
|
|
// default_domain, it is an error.
|
|
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
|
|
struct BOOST_PP_CAT(deduce_domain, N)
|
|
{
|
|
#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
|
|
// The function overloading trick doesn't work on MSVC-7.1, so
|
|
// do it the hard (expensive) way.
|
|
typedef
|
|
typename mpl::eval_if_c<
|
|
is_same<typename domain_of<A0>::type, default_domain>::value
|
|
, BOOST_PP_CAT(deduce_domain, BOOST_PP_DEC(N))<BOOST_PP_ENUM_SHIFTED_PARAMS(N, A)>
|
|
, domain_of<A0>
|
|
>::type
|
|
type;
|
|
#else
|
|
#define M0(N, F) char (&F)[BOOST_PP_INC(N)]
|
|
static M0(BOOST_PROTO_MAX_ARITY, deducer(
|
|
BOOST_PP_ENUM_PARAMS(N, dont_care BOOST_PP_INTERCEPT)));
|
|
#define M1(Z, X, DATA) \
|
|
typedef typename domain_of<BOOST_PP_CAT(A, X)>::type BOOST_PP_CAT(D, X); \
|
|
static BOOST_PP_CAT(D, X) &BOOST_PP_CAT(d, X); \
|
|
template<typename T> \
|
|
static M0(X, deducer( \
|
|
BOOST_PP_ENUM_PARAMS_Z(Z, X, default_domain BOOST_PP_INTERCEPT) \
|
|
BOOST_PP_COMMA_IF(X) T \
|
|
BOOST_PP_ENUM_TRAILING_PARAMS_Z( \
|
|
Z \
|
|
, BOOST_PP_DEC(BOOST_PP_SUB(N, X)) \
|
|
, typename nondeduced_domain<T>::type BOOST_PP_INTERCEPT \
|
|
) \
|
|
));
|
|
BOOST_PP_REPEAT(N, M1, ~)
|
|
#undef M0
|
|
#undef M1
|
|
BOOST_STATIC_CONSTANT(int, value = sizeof(deducer(BOOST_PP_ENUM_PARAMS(N, d))) - 1);
|
|
typedef typename select_nth<value, BOOST_PP_ENUM_PARAMS(N, D)>::type type;
|
|
#endif
|
|
};
|
|
|
|
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 proto::expr<
|
|
Tag
|
|
, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD_TYPE, (A, ~, Domain)) >
|
|
> expr_type;
|
|
|
|
typedef typename Domain::template result<void(expr_type)>::type result_type;
|
|
|
|
result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<A, >::type a)) const
|
|
{
|
|
expr_type that = {
|
|
BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD, (A, a, Domain))
|
|
};
|
|
return Domain()(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 proto::expr<
|
|
Tag
|
|
, BOOST_PP_CAT(list, N)<
|
|
BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE, ~)
|
|
>
|
|
> expr_type;
|
|
|
|
typedef typename Domain::template result<void(expr_type)>::type type;
|
|
|
|
static type const call(Sequence const &sequence)
|
|
{
|
|
BOOST_PROTO_FUSION_ITERATORS(N)
|
|
expr_type that = {
|
|
BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AS_CHILD_AT, ~)
|
|
};
|
|
return Domain()(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
|
|
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
|
|
|
|
#elif BOOST_PP_ITERATION_FLAGS() == 4
|
|
|
|
#define N BOOST_PP_ITERATION()
|
|
|
|
/// \overload
|
|
///
|
|
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
|
|
detail::BOOST_PP_CAT(implicit_expr_, N)<BOOST_PP_ENUM_PARAMS(N, A)> const
|
|
implicit_expr(BOOST_PP_ENUM_BINARY_PARAMS(N, A, &a))
|
|
{
|
|
detail::BOOST_PP_CAT(implicit_expr_, N)<BOOST_PP_ENUM_PARAMS(N, A)> that
|
|
= {BOOST_PP_ENUM_PARAMS(N, a)};
|
|
return that;
|
|
}
|
|
|
|
#undef N
|
|
|
|
#endif // BOOST_PP_IS_ITERATING
|