311 lines
11 KiB
C++
Executable File
311 lines
11 KiB
C++
Executable File
///////////////////////////////////////////////////////////////////////////////
|
|
/// \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 EDSLs 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 EDSLs 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 EDSLs 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 EDSLs 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 EDSLs 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
|