| /////////////////////////////////////////////////////////////////////////////// |
| /// \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 DSELs 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 DSELs 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 DSELs 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 DSELs 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 DSELs 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 |