[ceph.git] / ceph / src / boost / libs / proto / include / boost / proto / repeat.hpp

///////////////////////////////////////////////////////////////////////////////
/// \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
Commit	Line	Data
7c673cae FG	1	///////////////////////////////////////////////////////////////////////////////
	2	/// \file repeat.hpp
	3	/// Contains macros to ease the generation of repetitious code constructs
	4	//
	5	// Copyright 2008 Eric Niebler. Distributed under the Boost
	6	// Software License, Version 1.0. (See accompanying file
	7	// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
	8
	9	#ifndef BOOST_PROTO_REPEAT_HPP_EAN_11_24_2008
	10	#define BOOST_PROTO_REPEAT_HPP_EAN_11_24_2008
	11
	12	#include <boost/preprocessor/cat.hpp>
	13	#include <boost/preprocessor/facilities/intercept.hpp>
	14	#include <boost/preprocessor/repetition/enum.hpp>
	15	#include <boost/preprocessor/repetition/enum_params.hpp>
	16	#include <boost/preprocessor/repetition/enum_binary_params.hpp>
	17	#include <boost/preprocessor/iteration/local.hpp>
	18	#include <boost/preprocessor/tuple/elem.hpp>
	19	#include <boost/proto/proto_fwd.hpp> // for BOOST_PROTO_MAX_ARITY
	20
	21	////////////////////////////////////////////
	22	/// INTERNAL ONLY
	23	#define BOOST_PROTO_ref_a_aux(Z, N, DATA)\
	24	boost::ref(BOOST_PP_CAT(proto_a, N))
	25
	26	/// \brief Generates a sequence like <tt>typename A0, typename A1, ...</tt>
	27	///
	28	#define BOOST_PROTO_typename_A(N)\
	29	BOOST_PP_ENUM_PARAMS(N, typename proto_A)
	30
	31	/// \brief Generates a sequence like <tt>A0 const &, A1 const &, ...</tt>
	32	///
	33	#define BOOST_PROTO_A_const_ref(N)\
	34	BOOST_PP_ENUM_BINARY_PARAMS(N, proto_A, const & BOOST_PP_INTERCEPT)
	35
	36	/// \brief Generates a sequence like <tt>A0 &, A1 &, ...</tt>
	37	///
	38	#define BOOST_PROTO_A_ref(N)\
	39	BOOST_PP_ENUM_BINARY_PARAMS(N, proto_A, & BOOST_PP_INTERCEPT)
	40
	41	/// \brief Generates a sequence like <tt>A0, A1, ...</tt>
	42	///
	43	#define BOOST_PROTO_A(N)\
	44	BOOST_PP_ENUM_PARAMS(N, proto_A)
	45
	46	/// \brief Generates a sequence like <tt>A0 const, A1 const, ...</tt>
	47	///
	48	#define BOOST_PROTO_A_const(N)\
	49	BOOST_PP_ENUM_PARAMS(N, const proto_A)
	50
	51	/// \brief Generates a sequence like <tt>A0 const &a0, A1 const &a0, ...</tt>
	52	///
	53	#define BOOST_PROTO_A_const_ref_a(N)\
	54	BOOST_PP_ENUM_BINARY_PARAMS(N, proto_A, const &proto_a)
	55
	56	/// \brief Generates a sequence like <tt>A0 &a0, A1 &a0, ...</tt>
	57	///
	58	#define BOOST_PROTO_A_ref_a(N)\
	59	BOOST_PP_ENUM_BINARY_PARAMS(N, proto_A, &proto_a)
	60
	61	/// \brief Generates a sequence like <tt>boost::ref(a0), boost::ref(a1), ...</tt>
	62	///
	63	#define BOOST_PROTO_ref_a(N)\
	64	BOOST_PP_ENUM(N, BOOST_PROTO_ref_a_aux, ~)
65
66	/// \brief Generates a sequence like <tt>a0, a1, ...</tt>
67	///
68	#define BOOST_PROTO_a(N)\
69	BOOST_PP_ENUM_PARAMS(N, proto_a)
70
71	////////////////////////////////////////////
72	/// INTERNAL ONLY
73	#define BOOST_PROTO_invoke(Z, N, DATA)\
74	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))
75
76	/// \brief Repeatedly invoke the specified macro.
77	///
78	/// BOOST_PROTO_REPEAT_FROM_TO_EX() is used generate the kind of repetitive code that is typical
79	/// of EDSLs built with Proto. BOOST_PROTO_REPEAT_FROM_TO_EX(FROM, TO, MACRO, typename_A, A, A_a, a) is equivalent to:
80	///
81	/// \code
82	/// MACRO(FROM, typename_A, A, A_a, a)
83	/// MACRO(FROM+1, typename_A, A, A_a, a)
84	/// ...
85	/// MACRO(TO-1, typename_A, A, A_a, a)
86	/// \endcode
87	#define BOOST_PROTO_REPEAT_FROM_TO_EX(FROM, TO, MACRO, typename_A, A, A_a, a)\
88	BOOST_PP_REPEAT_FROM_TO(FROM, TO, BOOST_PROTO_invoke, (MACRO, typename_A, A, A_a, a))
89
90	/// \brief Repeatedly invoke the specified macro.
91	///
92	/// BOOST_PROTO_REPEAT_FROM_TO() is used generate the kind of repetitive code that is typical
93	/// of EDSLs built with Proto. BOOST_PROTO_REPEAT_FROM_TO(FROM, TO, MACRO) is equivalent to:
94	///
95	/// \code
96	/// MACRO(FROM, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a)
97	/// MACRO(FROM+1, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a)
98	/// ...
99	/// MACRO(TO-1, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a)
100	/// \endcode
101	///
102	/// Example:
103	///
104	/** \code
105
106	// Generate BOOST_PROTO_MAX_ARITY-1 overloads of the
107	// following construct() function template.
108	#define M0(N, typename_A, A_const_ref, A_const_ref_a, ref_a) \
109	template<typename T, typename_A(N)> \
110	typename proto::result_of::make_expr< \
111	proto::tag::function \
112	, construct_helper<T> \
113	, A_const_ref(N) \
114	>::type const \
115	construct(A_const_ref_a(N)) \
116	{ \
117	return proto::make_expr< \
118	proto::tag::function \
119	>( \
120	construct_helper<T>() \
121	, ref_a(N) \
122	); \
123	}
124	BOOST_PROTO_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, M0)
125	#undef M0
126
127	\endcode
128	**/
129	/// The above invocation of BOOST_PROTO_REPEAT_FROM_TO() will generate
130	/// the following code:
131	///
132	/// \code
133	/// template<typename T, typename A0>
134	/// typename proto::result_of::make_expr<
135	/// proto::tag::function
136	/// , construct_helper<T>
137	/// , A0 const &
138	/// >::type const
139	/// construct(A0 const & a0)
140	/// {
141	/// return proto::make_expr<
142	/// proto::tag::function
143	/// >(
144	/// construct_helper<T>()
145	/// , boost::ref(a0)
146	/// );
147	/// }
148	///
149	/// template<typename T, typename A0, typename A1>
150	/// typename proto::result_of::make_expr<
151	/// proto::tag::function
152	/// , construct_helper<T>
153	/// , A0 const &
154	/// , A1 const &
155	/// >::type const
156	/// construct(A0 const & a0, A1 const & a1)
157	/// {
158	/// return proto::make_expr<
159	/// proto::tag::function
160	/// >(
161	/// construct_helper<T>()
162	/// , boost::ref(a0)
163	/// , boost::ref(a1)
164	/// );
165	/// }
166	///
167	/// // ... and so on, up to BOOST_PROTO_MAX_ARITY-1 arguments ...
168	/// \endcode
169	#define BOOST_PROTO_REPEAT_FROM_TO(FROM, TO, MACRO)\
170	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)
171
172	/// \brief Repeatedly invoke the specified macro.
173	///
174	/// BOOST_PROTO_REPEAT_EX() is used generate the kind of repetitive code that is typical
175	/// of EDSLs built with Proto. BOOST_PROTO_REPEAT_EX(MACRO, typename_A, A, A_a, a) is equivalent to:
176	///
177	/// \code
178	/// MACRO(1, typename_A, A, A_a, a)
179	/// MACRO(2, typename_A, A, A_a, a)
180	/// ...
181	/// MACRO(BOOST_PROTO_MAX_ARITY, typename_A, A, A_a, a)
182	/// \endcode
183	#define BOOST_PROTO_REPEAT_EX(MACRO, typename_A, A, A_a, a)\
184	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)
185
186	/// \brief Repeatedly invoke the specified macro.
187	///
188	/// BOOST_PROTO_REPEAT() is used generate the kind of repetitive code that is typical
189	/// of EDSLs built with Proto. BOOST_PROTO_REPEAT(MACRO) is equivalent to:
190	///
191	/// \code
192	/// MACRO(1, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a)
193	/// MACRO(2, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a)
194	/// ...
195	/// MACRO(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a)
196	/// \endcode
197	#define BOOST_PROTO_REPEAT(MACRO)\
198	BOOST_PROTO_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), MACRO)
199
200	/// \brief Repeatedly invoke the specified macro.
201	///
202	/// BOOST_PROTO_LOCAL_ITERATE() is used generate the kind of repetitive code that is typical
203	/// of EDSLs built with Proto. This macro causes the user-defined macro BOOST_PROTO_LOCAL_MACRO to
204	/// be expanded with values in the range specified by BOOST_PROTO_LOCAL_LIMITS.
205	///
206	/// Usage:
207	///
208	/// \code
209	/// #include BOOST_PROTO_LOCAL_ITERATE()
210	/// \endcode
211	///
212	/// Example:
213	///
214	/** \code
215
216	// Generate BOOST_PROTO_MAX_ARITY-1 overloads of the
217	// following construct() function template.
218	#define BOOST_PROTO_LOCAL_MACRO(N, typename_A, A_const_ref, \
219	A_const_ref_a, ref_a) \
220	template<typename T, typename_A(N)> \
221	typename proto::result_of::make_expr< \
222	proto::tag::function \
223	, construct_helper<T> \
224	, A_const_ref(N) \
225	>::type const \
226	construct(A_const_ref_a(N)) \
227	{ \
228	return proto::make_expr< \
229	proto::tag::function \
230	>( \
231	construct_helper<T>() \
232	, ref_a(N) \
233	); \
234	}
235	#define BOOST_PROTO_LOCAL_LIMITS (1, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY))
236	#include BOOST_PROTO_LOCAL_ITERATE()
237
238	\endcode
239	**/
240	/// The above inclusion of BOOST_PROTO_LOCAL_ITERATE() will generate
241	/// the following code:
242	///
243	/// \code
244	/// template<typename T, typename A0>
245	/// typename proto::result_of::make_expr<
246	/// proto::tag::function
247	/// , construct_helper<T>
248	/// , A0 const &
249	/// >::type const
250	/// construct(A0 const & a0)
251	/// {
252	/// return proto::make_expr<
253	/// proto::tag::function
254	/// >(
255	/// construct_helper<T>()
256	/// , boost::ref(a0)
257	/// );
258	/// }
259	///
260	/// template<typename T, typename A0, typename A1>
261	/// typename proto::result_of::make_expr<
262	/// proto::tag::function
263	/// , construct_helper<T>
264	/// , A0 const &
265	/// , A1 const &
266	/// >::type const
267	/// construct(A0 const & a0, A1 const & a1)
268	/// {
269	/// return proto::make_expr<
270	/// proto::tag::function
271	/// >(
272	/// construct_helper<T>()
273	/// , boost::ref(a0)
274	/// , boost::ref(a1)
275	/// );
276	/// }
277	///
278	/// // ... and so on, up to BOOST_PROTO_MAX_ARITY-1 arguments ...
279	/// \endcode
280	///
281	/// If BOOST_PROTO_LOCAL_LIMITS is not defined by the user, it defaults
282	/// to (1, BOOST_PROTO_MAX_ARITY)
283	///
284	/// At each iteration, BOOST_PROTO_LOCAL_MACRO is invoked with the current
285	/// iteration number and the following 4 macro parameters:
286	///
287	/// \li BOOST_PROTO_LOCAL_typename_A
288	/// \li BOOST_PROTO_LOCAL_A
289	/// \li BOOST_PROTO_LOCAL_A_a
290	/// \li BOOST_PROTO_LOCAL_a
291	///
292	/// If these macros are not defined by the user, they default respectively to:
293	///
294	/// \li BOOST_PROTO_typename_A
295	/// \li BOOST_PROTO_A_const_ref
296	/// \li BOOST_PROTO_A_const_ref_a
297	/// \li BOOST_PROTO_ref_a
298	///
299	/// After including BOOST_PROTO_LOCAL_ITERATE(), the following macros are
300	/// automatically undefined:
301	///
302	/// \li BOOST_PROTO_LOCAL_MACRO
303	/// \li BOOST_PROTO_LOCAL_LIMITS
304	/// \li BOOST_PROTO_LOCAL_typename_A
305	/// \li BOOST_PROTO_LOCAL_A
306	/// \li BOOST_PROTO_LOCAL_A_a
307	/// \li BOOST_PROTO_LOCAL_a
308	#define BOOST_PROTO_LOCAL_ITERATE() <boost/proto/detail/local.hpp>
309
310	#endif