MACRO BOOST_P(3)

NAME
BOOST_PROTO_LOCAL_ITERATE - Vertical repetition of a user-supplied macro.

SYNOPSIS

// In header: <boost/proto/repeat.hpp>
BOOST_PROTO_LOCAL_ITERATE()

DESCRIPTION

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:

    #include BOOST_PROTO_LOCAL_ITERATE()

Example:

    // 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()

The above inclusion of BOOST_PROTO_LOCAL_ITERATE() will generate the following 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 ...

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:

    &#8226; BOOST_PROTO_LOCAL_typename_A.RE

        &#8226; BOOST_PROTO_LOCAL_A.RE

            &#8226; BOOST_PROTO_LOCAL_A_a.RE

                &#8226; BOOST_PROTO_LOCAL_a.RE

            If these macros are not defined by the user, they default respectively to:

                &#8226; BOOST_PROTO_typename_A.RE

                    &#8226; BOOST_PROTO_A_const_ref.RE

                        &#8226; BOOST_PROTO_A_const_ref_a.RE

                            &#8226; BOOST_PROTO_ref_a.RE

                        After including BOOST_PROTO_LOCAL_ITERATE(), the following macros are automatically undefined:

                            &#8226; BOOST_PROTO_LOCAL_MACRO.RE

                                &#8226; BOOST_PROTO_LOCAL_LIMITS.RE

                                    &#8226; BOOST_PROTO_LOCAL_typename_A.RE

                                        &#8226; BOOST_PROTO_LOCAL_A.RE

                                            &#8226; BOOST_PROTO_LOCAL_A_a.RE

                                                &#8226; BOOST_PROTO_LOCAL_a.RE