boost/proto/generate.hpp
#ifndef BOOST_PP_IS_ITERATING
///////////////////////////////////////////////////////////////////////////////
/// \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>
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;
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;
static type const call(proto::basic_expr<Tag, term<Arg>, 0> const &e)
{
type that = {e.child0};
return that;
}
};
#define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/generate.hpp>))
#include BOOST_PP_ITERATE()
#undef BOOST_PROTO_DEFINE_BY_VALUE
#undef BOOST_PROTO_DEFINE_BY_VALUE_TYPE
}
/// \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>
#ifdef BOOST_PROTO_STRICT_RESULT_OF
Expr
#else
Expr const &
#endif
operator ()(Expr const &e) const
{
return e;
}
};
/// \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>
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>
Extends<Expr> operator ()(Expr const &e) const
{
Extends<Expr> that = {e};
return that;
}
};
/// \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>
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>
typename result<compose_generators(Expr)>::type operator ()(Expr const &e) const
{
return Second()(First()(e));
}
};
/// \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 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::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::default_generator(Expr)>
{
typedef Expr type;
};
#endif
}
#endif // BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007
#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;
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;
static type const call(src_type const &e)
{
type that = {
BOOST_PP_ENUM_PARAMS(N, e.child)
};
return that;
}
};
#undef N
#endif
