Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/proto/generate.hpp')
| -rw-r--r-- | 3rdParty/Boost/src/boost/proto/generate.hpp | 466 |
1 files changed, 466 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/proto/generate.hpp b/3rdParty/Boost/src/boost/proto/generate.hpp new file mode 100644 index 0000000..5009cca --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/generate.hpp @@ -0,0 +1,466 @@ +#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 |