Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

Click here to view the latest version of this page.
PrevUpHomeNext

Macro BOOST_PROTO_LOCAL_ITERATE

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:

  • BOOST_PROTO_LOCAL_typename_A
  • BOOST_PROTO_LOCAL_A
  • BOOST_PROTO_LOCAL_A_a
  • BOOST_PROTO_LOCAL_a

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

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

  • BOOST_PROTO_LOCAL_MACRO
  • BOOST_PROTO_LOCAL_LIMITS
  • BOOST_PROTO_LOCAL_typename_A
  • BOOST_PROTO_LOCAL_A
  • BOOST_PROTO_LOCAL_A_a
  • BOOST_PROTO_LOCAL_a


PrevUpHomeNext