]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Copyright Daniel Wallin 2006. Use, modification and distribution is |
2 | // subject to the Boost Software License, Version 1.0. (See accompanying | |
3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
4 | ||
5 | #ifndef BOOST_PARAMETER_PREPROCESSOR_060206_HPP | |
6 | # define BOOST_PARAMETER_PREPROCESSOR_060206_HPP | |
7 | ||
8 | # include <boost/parameter/parameters.hpp> | |
9 | # include <boost/parameter/binding.hpp> | |
10 | # include <boost/parameter/match.hpp> | |
11 | ||
12 | # include <boost/parameter/aux_/parenthesized_type.hpp> | |
13 | # include <boost/parameter/aux_/cast.hpp> | |
14 | # include <boost/parameter/aux_/preprocessor/flatten.hpp> | |
15 | ||
16 | # include <boost/preprocessor/repetition/repeat_from_to.hpp> | |
17 | # include <boost/preprocessor/comparison/equal.hpp> | |
18 | # include <boost/preprocessor/control/if.hpp> | |
19 | # include <boost/preprocessor/control/iif.hpp> | |
20 | # include <boost/preprocessor/control/expr_if.hpp> | |
21 | # include <boost/preprocessor/repetition/enum_params.hpp> | |
22 | # include <boost/preprocessor/repetition/enum_binary_params.hpp> | |
23 | # include <boost/preprocessor/repetition/enum_trailing.hpp> | |
24 | # include <boost/preprocessor/seq/first_n.hpp> | |
25 | # include <boost/preprocessor/seq/for_each_product.hpp> | |
26 | # include <boost/preprocessor/seq/for_each_i.hpp> | |
27 | # include <boost/preprocessor/tuple/elem.hpp> | |
28 | # include <boost/preprocessor/tuple/eat.hpp> | |
29 | # include <boost/preprocessor/seq/fold_left.hpp> | |
30 | # include <boost/preprocessor/seq/push_back.hpp> | |
31 | # include <boost/preprocessor/seq/size.hpp> | |
32 | # include <boost/preprocessor/seq/enum.hpp> | |
33 | # include <boost/preprocessor/seq/push_back.hpp> | |
34 | ||
35 | # include <boost/preprocessor/detail/is_nullary.hpp> | |
36 | ||
37 | # include <boost/mpl/always.hpp> | |
38 | # include <boost/mpl/apply_wrap.hpp> | |
39 | ||
40 | namespace boost { namespace parameter { namespace aux { | |
41 | ||
42 | # if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) | |
43 | ||
44 | // Given Match, which is "void x" where x is an argument matching | |
45 | // criterion, extract a corresponding MPL predicate. | |
46 | template <class Match> | |
47 | struct unwrap_predicate; | |
48 | ||
49 | // Match anything | |
50 | template <> | |
51 | struct unwrap_predicate<void*> | |
52 | { | |
53 | typedef mpl::always<mpl::true_> type; | |
54 | }; | |
55 | ||
56 | #if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580)) | |
57 | ||
58 | typedef void* voidstar; | |
59 | ||
60 | // A matching predicate is explicitly specified | |
61 | template <class Predicate> | |
62 | struct unwrap_predicate<voidstar (Predicate)> | |
63 | { | |
64 | typedef Predicate type; | |
65 | }; | |
66 | ||
67 | #else | |
68 | ||
69 | // A matching predicate is explicitly specified | |
70 | template <class Predicate> | |
71 | struct unwrap_predicate<void *(Predicate)> | |
72 | { | |
73 | typedef Predicate type; | |
74 | }; | |
75 | ||
76 | #endif | |
77 | ||
78 | ||
79 | // A type to which the argument is supposed to be convertible is | |
80 | // specified | |
81 | template <class Target> | |
82 | struct unwrap_predicate<void (Target)> | |
83 | { | |
84 | typedef is_convertible<mpl::_, Target> type; | |
85 | }; | |
86 | ||
87 | // Recast the ParameterSpec's nested match metafunction as a free metafunction | |
88 | template < | |
89 | class Parameters | |
90 | , BOOST_PP_ENUM_BINARY_PARAMS( | |
91 | BOOST_PARAMETER_MAX_ARITY, class A, = boost::parameter::void_ BOOST_PP_INTERCEPT | |
92 | ) | |
93 | > | |
94 | struct match | |
95 | : Parameters::template match< | |
96 | BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, A) | |
97 | > | |
98 | {}; | |
99 | # endif | |
100 | ||
101 | # undef false_ | |
102 | ||
103 | template < | |
104 | class Parameters | |
105 | , BOOST_PP_ENUM_BINARY_PARAMS( | |
106 | BOOST_PARAMETER_MAX_ARITY, class A, = boost::parameter::void_ BOOST_PP_INTERCEPT | |
107 | ) | |
108 | > | |
109 | struct argument_pack | |
110 | { | |
111 | typedef typename make_arg_list< | |
112 | typename BOOST_PARAMETER_build_arg_list( | |
113 | BOOST_PARAMETER_MAX_ARITY, make_items, typename Parameters::parameter_spec, A | |
114 | )::type | |
115 | , typename Parameters::deduced_list | |
116 | , tag_keyword_arg | |
117 | , mpl::false_ | |
118 | >::type result; | |
119 | typedef typename mpl::first<result>::type type; | |
120 | }; | |
121 | ||
122 | // Works around VC6 problem where it won't accept rvalues. | |
123 | template <class T> | |
124 | T& as_lvalue(T& value, long) | |
125 | { | |
126 | return value; | |
127 | } | |
128 | ||
129 | template <class T> | |
130 | T const& as_lvalue(T const& value, int) | |
131 | { | |
132 | return value; | |
133 | } | |
134 | ||
135 | ||
136 | # if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
137 | ||
138 | template <class Predicate, class T, class Args> | |
139 | struct apply_predicate | |
140 | { | |
141 | BOOST_MPL_ASSERT(( | |
142 | mpl::and_<mpl::false_,T> | |
143 | )); | |
144 | ||
145 | typedef typename mpl::if_< | |
146 | typename mpl::apply2<Predicate,T,Args>::type | |
147 | , char | |
148 | , int | |
149 | >::type type; | |
150 | }; | |
151 | ||
152 | template <class P> | |
153 | struct funptr_predicate | |
154 | { | |
155 | static P p; | |
156 | ||
157 | template <class T, class Args, class P0> | |
158 | static typename apply_predicate<P0,T,Args>::type | |
159 | check_predicate(type<T>, Args*, void**(*)(P0)); | |
160 | ||
161 | template <class T, class Args, class P0> | |
162 | static typename mpl::if_< | |
163 | is_convertible<T,P0> | |
164 | , char | |
165 | , int | |
166 | >::type check_predicate(type<T>, Args*, void*(*)(P0)); | |
167 | ||
168 | template <class T, class Args> | |
169 | struct apply | |
170 | { | |
171 | BOOST_STATIC_CONSTANT(bool, result = | |
172 | sizeof(check_predicate(boost::type<T>(), (Args*)0, &p)) == 1 | |
173 | ); | |
174 | ||
175 | typedef mpl::bool_<apply<T,Args>::result> type; | |
176 | }; | |
177 | }; | |
178 | ||
179 | template <> | |
180 | struct funptr_predicate<void**> | |
181 | : mpl::always<mpl::true_> | |
182 | {}; | |
183 | ||
184 | # endif | |
185 | ||
186 | }}} // namespace boost::parameter::aux | |
187 | ||
188 | # if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
189 | // From Paul Mensonides | |
190 | # define BOOST_PARAMETER_IS_NULLARY(x) \ | |
191 | BOOST_PP_SPLIT(1, BOOST_PARAMETER_IS_NULLARY_C x BOOST_PP_COMMA() 0) \ | |
192 | /**/ | |
193 | # define BOOST_PARAMETER_IS_NULLARY_C() \ | |
194 | ~, 1 BOOST_PP_RPAREN() \ | |
195 | BOOST_PP_TUPLE_EAT(2) BOOST_PP_LPAREN() ~ \ | |
196 | /**/ | |
197 | # else | |
198 | # define BOOST_PARAMETER_IS_NULLARY(x) BOOST_PP_IS_NULLARY(x) | |
199 | # endif | |
200 | ||
201 | # define BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_static () | |
202 | # define BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \ | |
203 | BOOST_PARAMETER_IS_NULLARY( \ | |
204 | BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_,name) \ | |
205 | ) | |
206 | ||
207 | # if !defined(BOOST_MSVC) | |
208 | # define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_static | |
209 | # define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC(name) \ | |
210 | BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_, name) | |
211 | # else | |
212 | // Workaround for MSVC preprocessor. | |
213 | // | |
214 | // When stripping static from "static f", msvc will produce | |
215 | // " f". The leading whitespace doesn't go away when pasting | |
216 | // the token with something else, so this thing is a hack to | |
217 | // strip the whitespace. | |
218 | # define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_static ( | |
219 | # define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_AUX(name) \ | |
220 | BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_, name)) | |
221 | # define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC(name) \ | |
222 | BOOST_PP_SEQ_HEAD( \ | |
223 | BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_AUX(name) \ | |
224 | ) | |
225 | # endif | |
226 | ||
227 | # define BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \ | |
228 | BOOST_PP_EXPR_IF( \ | |
229 | BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \ | |
230 | , static \ | |
231 | ) | |
232 | ||
233 | # define BOOST_PARAMETER_MEMBER_FUNCTION_NAME(name) \ | |
234 | BOOST_PP_IF( \ | |
235 | BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \ | |
236 | , BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC \ | |
237 | , name BOOST_PP_TUPLE_EAT(1) \ | |
238 | )(name) | |
239 | ||
240 | // Calculates [begin, end) arity range. | |
241 | ||
242 | # define BOOST_PARAMETER_ARITY_RANGE_M_optional(state) state | |
243 | # define BOOST_PARAMETER_ARITY_RANGE_M_deduced_optional(state) state | |
244 | # define BOOST_PARAMETER_ARITY_RANGE_M_required(state) BOOST_PP_INC(state) | |
245 | # define BOOST_PARAMETER_ARITY_RANGE_M_deduced_required(state) BOOST_PP_INC(state) | |
246 | ||
247 | # define BOOST_PARAMETER_ARITY_RANGE_M(s, state, x) \ | |
248 | BOOST_PP_CAT( \ | |
249 | BOOST_PARAMETER_ARITY_RANGE_M_ \ | |
250 | , BOOST_PARAMETER_FN_ARG_QUALIFIER(x) \ | |
251 | )(state) | |
252 | /**/ | |
253 | ||
254 | # define BOOST_PARAMETER_ARITY_RANGE(args) \ | |
255 | ( \ | |
256 | BOOST_PP_SEQ_FOLD_LEFT(BOOST_PARAMETER_ARITY_RANGE_M, 0, args) \ | |
257 | , BOOST_PP_INC(BOOST_PP_SEQ_SIZE(args)) \ | |
258 | ) | |
259 | /**/ | |
260 | ||
261 | // Accessor macros for the argument specs tuple. | |
262 | # define BOOST_PARAMETER_FN_ARG_QUALIFIER(x) \ | |
263 | BOOST_PP_TUPLE_ELEM(4,0,x) | |
264 | /**/ | |
265 | ||
266 | # define BOOST_PARAMETER_FN_ARG_NAME(x) \ | |
267 | BOOST_PP_TUPLE_ELEM(4,1,x) | |
268 | /**/ | |
269 | ||
270 | # define BOOST_PARAMETER_FN_ARG_PRED(x) \ | |
271 | BOOST_PP_TUPLE_ELEM(4,2,x) | |
272 | /**/ | |
273 | ||
274 | # define BOOST_PARAMETER_FN_ARG_DEFAULT(x) \ | |
275 | BOOST_PP_TUPLE_ELEM(4,3,x) | |
276 | /**/ | |
277 | ||
278 | # define BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_out(x) | |
279 | # define BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_in_out(x) | |
280 | ||
281 | // Returns 1 if x is either "out(k)" or "in_out(k)". | |
282 | # define BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER(x) \ | |
283 | BOOST_PP_IS_EMPTY( \ | |
284 | BOOST_PP_CAT(BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_, x) \ | |
285 | ) \ | |
286 | /**/ | |
287 | ||
288 | # define BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_out(x) x | |
289 | # define BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_in_out(x) x | |
290 | # define BOOST_PARAMETER_FUNCTION_KEYWORD_GET(x) \ | |
291 | BOOST_PP_CAT(BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_, x) | |
292 | /**/ | |
293 | ||
294 | // Returns the keyword of x, where x is either a keyword qualifier | |
295 | // or a keyword. | |
296 | // | |
297 | // k => k | |
298 | // out(k) => k | |
299 | // in_out(k) => k | |
300 | // | |
301 | # define BOOST_PARAMETER_FUNCTION_KEYWORD(x) \ | |
302 | BOOST_PP_IF( \ | |
303 | BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER(x) \ | |
304 | , BOOST_PARAMETER_FUNCTION_KEYWORD_GET \ | |
305 | , x BOOST_PP_TUPLE_EAT(1) \ | |
306 | )(x) | |
307 | /**/ | |
308 | ||
309 | # define BOOST_PARAMETER_FN_ARG_KEYWORD(x) \ | |
310 | BOOST_PARAMETER_FUNCTION_KEYWORD( \ | |
311 | BOOST_PARAMETER_FN_ARG_NAME(x) \ | |
312 | ) | |
313 | ||
314 | // Builds forwarding functions. | |
315 | ||
316 | # define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z(z, n) \ | |
317 | template<BOOST_PP_ENUM_PARAMS_Z(z, n, class ParameterArgumentType)> | |
318 | /**/ | |
319 | ||
320 | # if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) | |
321 | # define BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n) \ | |
322 | , typename boost::parameter::aux::match< \ | |
323 | parameters, BOOST_PP_ENUM_PARAMS(n, ParameterArgumentType) \ | |
324 | >::type = parameters() | |
325 | # else | |
326 | # define BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n) | |
327 | # endif | |
328 | /**/ | |
329 | ||
330 | # define BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(base) \ | |
331 | BOOST_PP_CAT( \ | |
332 | boost_param_parameters_ \ | |
333 | , BOOST_PP_CAT(__LINE__, BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) \ | |
334 | ) | |
335 | ||
336 | // Produce a name for a result type metafunction for the function | |
337 | // named base | |
338 | # define BOOST_PARAMETER_FUNCTION_RESULT_NAME(base) \ | |
339 | BOOST_PP_CAT( \ | |
340 | boost_param_result_ \ | |
341 | , BOOST_PP_CAT(__LINE__,BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) \ | |
342 | ) | |
343 | ||
344 | // Can't do boost_param_impl_ ## basee because base might start with an underscore | |
345 | // daniel: what? how is that relevant? the reason for using CAT() is to make sure | |
346 | // base is expanded. i'm not sure we need to here, but it's more stable to do it. | |
347 | # define BOOST_PARAMETER_IMPL(base) \ | |
348 | BOOST_PP_CAT(boost_param_impl,BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) | |
349 | ||
350 | # define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00(z, n, r, data, elem) \ | |
351 | BOOST_PP_IF( \ | |
352 | n \ | |
353 | , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z, BOOST_PP_TUPLE_EAT(2) \ | |
354 | )(z,n) \ | |
355 | BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(BOOST_PP_TUPLE_ELEM(7,3,data)) \ | |
356 | inline \ | |
357 | BOOST_PP_EXPR_IF(n, typename) \ | |
358 | BOOST_PARAMETER_FUNCTION_RESULT_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))< \ | |
359 | BOOST_PP_EXPR_IF(n, typename) \ | |
360 | boost::parameter::aux::argument_pack< \ | |
361 | BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data)) \ | |
362 | BOOST_PP_COMMA_IF(n) \ | |
363 | BOOST_PP_IF( \ | |
364 | n, BOOST_PP_SEQ_ENUM, BOOST_PP_TUPLE_EAT(1) \ | |
365 | )(elem) \ | |
366 | >::type \ | |
367 | >::type \ | |
368 | BOOST_PARAMETER_MEMBER_FUNCTION_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))( \ | |
369 | BOOST_PP_IF( \ | |
370 | n \ | |
371 | , BOOST_PP_SEQ_FOR_EACH_I_R \ | |
372 | , BOOST_PP_TUPLE_EAT(4) \ | |
373 | )( \ | |
374 | r \ | |
375 | , BOOST_PARAMETER_FUNCTION_ARGUMENT \ | |
376 | , ~ \ | |
377 | , elem \ | |
378 | ) \ | |
379 | BOOST_PP_IF(n, BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z, BOOST_PP_TUPLE_EAT(4))( \ | |
380 | z \ | |
381 | , BOOST_PP_TUPLE_ELEM(7,3,data) \ | |
382 | , BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data)) \ | |
383 | , n \ | |
384 | ) \ | |
385 | ) BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(7,4,data), const) \ | |
386 | { \ | |
387 | return BOOST_PARAMETER_IMPL(BOOST_PP_TUPLE_ELEM(7,3,data))( \ | |
388 | BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))()( \ | |
389 | BOOST_PP_ENUM_PARAMS_Z(z, n, a) \ | |
390 | ) \ | |
391 | ); \ | |
392 | } | |
393 | /**/ | |
394 | ||
395 | # define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION0(r, data, elem) \ | |
396 | BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00( \ | |
397 | BOOST_PP_TUPLE_ELEM(7,0,data) \ | |
398 | , BOOST_PP_TUPLE_ELEM(7,1,data) \ | |
399 | , r \ | |
400 | , data \ | |
401 | , elem \ | |
402 | ) | |
403 | /**/ | |
404 | ||
405 | # define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_0(z, n, data) \ | |
406 | BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00( \ | |
407 | z, n, BOOST_PP_DEDUCE_R() \ | |
408 | , (z, n, BOOST_PP_TUPLE_REM(5) data) \ | |
409 | , ~ \ | |
410 | ) | |
411 | /**/ | |
412 | ||
413 | # define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_N(z, n, data) \ | |
414 | BOOST_PP_SEQ_FOR_EACH( \ | |
415 | BOOST_PARAMETER_FUNCTION_FWD_FUNCTION0 \ | |
416 | , (z, n, BOOST_PP_TUPLE_REM(5) data) \ | |
417 | , BOOST_PP_SEQ_FOR_EACH_PRODUCT( \ | |
418 | BOOST_PARAMETER_FUNCTION_FWD_PRODUCT \ | |
419 | , BOOST_PP_SEQ_FIRST_N( \ | |
420 | n, BOOST_PP_TUPLE_ELEM(5,3,data) \ | |
421 | ) \ | |
422 | ) \ | |
423 | ) | |
424 | /**/ | |
425 | ||
426 | # define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION(z, n, data) \ | |
427 | BOOST_PP_IF( \ | |
428 | n \ | |
429 | , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_N \ | |
430 | , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_0 \ | |
431 | )(z,n,data) \ | |
432 | /**/ | |
433 | ||
434 | # define BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS0( \ | |
435 | result,name,args,const_,combinations,range \ | |
436 | ) \ | |
437 | BOOST_PP_REPEAT_FROM_TO( \ | |
438 | BOOST_PP_TUPLE_ELEM(2,0,range), BOOST_PP_TUPLE_ELEM(2,1,range) \ | |
439 | , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION \ | |
440 | , (result,name,const_,combinations,BOOST_PP_TUPLE_ELEM(2,1,range)) \ | |
441 | ) | |
442 | /**/ | |
443 | ||
444 | # define BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS(result,name,args, const_, combinations) \ | |
445 | BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS0( \ | |
446 | result, name, args, const_, combinations, BOOST_PARAMETER_ARITY_RANGE(args) \ | |
447 | ) | |
448 | /**/ | |
449 | ||
450 | // Builds boost::parameter::parameters<> specialization | |
451 | # define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_optional(tag) \ | |
452 | optional<tag | |
453 | ||
454 | # define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_required(tag) \ | |
455 | required<tag | |
456 | ||
457 | # define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_deduced_optional(tag) \ | |
458 | optional<boost::parameter::deduced<tag> | |
459 | ||
460 | # define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_deduced_required(tag) \ | |
461 | required<boost::parameter::deduced<tag> | |
462 | ||
463 | # if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
464 | ||
465 | # define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \ | |
466 | BOOST_PP_COMMA_IF(i) \ | |
467 | boost::parameter::BOOST_PP_CAT( \ | |
468 | BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_ \ | |
469 | , BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \ | |
470 | )( \ | |
471 | tag_namespace::BOOST_PARAMETER_FUNCTION_KEYWORD( \ | |
472 | BOOST_PARAMETER_FN_ARG_KEYWORD(elem) \ | |
473 | ) \ | |
474 | ) \ | |
475 | , typename boost::parameter::aux::unwrap_predicate< \ | |
476 | void BOOST_PARAMETER_FN_ARG_PRED(elem) \ | |
477 | >::type \ | |
478 | > | |
479 | # elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
480 | # define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \ | |
481 | BOOST_PP_COMMA_IF(i) \ | |
482 | boost::parameter::BOOST_PP_CAT( \ | |
483 | BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_ \ | |
484 | , BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \ | |
485 | )( \ | |
486 | tag_namespace::BOOST_PARAMETER_FUNCTION_KEYWORD( \ | |
487 | BOOST_PARAMETER_FN_ARG_KEYWORD(elem) \ | |
488 | ) \ | |
489 | ) \ | |
490 | , boost::mpl::always<boost::mpl::true_> \ | |
491 | > | |
492 | # endif | |
493 | ||
494 | # define BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, base, args) \ | |
495 | template <class BoostParameterDummy> \ | |
496 | struct BOOST_PP_CAT( \ | |
497 | BOOST_PP_CAT(boost_param_params_, __LINE__) \ | |
498 | , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \ | |
499 | ) : boost::parameter::parameters< \ | |
500 | BOOST_PP_SEQ_FOR_EACH_I( \ | |
501 | BOOST_PARAMETER_FUNCTION_PARAMETERS_M, tag_namespace, args \ | |
502 | ) \ | |
503 | > \ | |
504 | {}; \ | |
505 | \ | |
506 | typedef BOOST_PP_CAT( \ | |
507 | BOOST_PP_CAT(boost_param_params_, __LINE__) \ | |
508 | , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \ | |
509 | )<int> | |
510 | ||
511 | // Defines result type metafunction | |
512 | # define BOOST_PARAMETER_FUNCTION_RESULT_ARG(z, _, i, x) \ | |
513 | BOOST_PP_COMMA_IF(i) class BOOST_PP_TUPLE_ELEM(3,1,x) | |
514 | /**/ | |
515 | ||
516 | # define BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args) \ | |
517 | template <class Args> \ | |
518 | struct BOOST_PARAMETER_FUNCTION_RESULT_NAME(name) \ | |
519 | { \ | |
520 | typedef typename BOOST_PARAMETER_PARENTHESIZED_TYPE(result) type; \ | |
521 | }; | |
522 | ||
523 | // Defines implementation function | |
524 | # define BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name) \ | |
525 | template <class Args> \ | |
526 | typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)< \ | |
527 | Args \ | |
528 | >::type BOOST_PARAMETER_IMPL(name)(Args const& args) | |
529 | ||
530 | # define BOOST_PARAMETER_FUNCTION_IMPL_FWD(name) \ | |
531 | BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name); | |
532 | /**/ | |
533 | ||
534 | # define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_required(state, arg) \ | |
535 | ( \ | |
536 | BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 0, state)) \ | |
537 | , BOOST_PP_SEQ_PUSH_BACK(BOOST_PP_TUPLE_ELEM(4, 1, state), arg) \ | |
538 | , BOOST_PP_TUPLE_ELEM(4, 2, state) \ | |
539 | , BOOST_PP_TUPLE_ELEM(4, 3, state) \ | |
540 | ) | |
541 | ||
542 | # define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_deduced_required(state, arg) \ | |
543 | BOOST_PARAMETER_FUNCTION_SPLIT_ARG_required(state, arg) | |
544 | ||
545 | # define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_optional(state, arg) \ | |
546 | ( \ | |
547 | BOOST_PP_TUPLE_ELEM(4, 0, state) \ | |
548 | , BOOST_PP_TUPLE_ELEM(4, 1, state) \ | |
549 | , BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 2, state)) \ | |
550 | , BOOST_PP_SEQ_PUSH_BACK(BOOST_PP_TUPLE_ELEM(4, 3, state), arg) \ | |
551 | ) | |
552 | ||
553 | # define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_deduced_optional(state, arg) \ | |
554 | BOOST_PARAMETER_FUNCTION_SPLIT_ARG_optional(state, arg) | |
555 | ||
556 | # define BOOST_PARAMETER_FUNCTION_SPLIT_ARG(s, state, arg) \ | |
557 | BOOST_PP_CAT( \ | |
558 | BOOST_PARAMETER_FUNCTION_SPLIT_ARG_ \ | |
559 | , BOOST_PARAMETER_FN_ARG_QUALIFIER(arg) \ | |
560 | )(state, arg) | |
561 | ||
562 | // Returns (required_count, required, optional_count, optionals) tuple | |
563 | # define BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args) \ | |
564 | BOOST_PP_SEQ_FOLD_LEFT( \ | |
565 | BOOST_PARAMETER_FUNCTION_SPLIT_ARG \ | |
566 | , (0,BOOST_PP_SEQ_NIL, 0,BOOST_PP_SEQ_NIL) \ | |
567 | , args \ | |
568 | ) | |
569 | ||
570 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME(keyword) \ | |
571 | BOOST_PP_CAT(BOOST_PP_CAT(keyword,_),type) | |
572 | ||
573 | // Helpers used as parameters to BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS. | |
574 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG(r, _, arg) \ | |
575 | , class BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME( \ | |
576 | BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \ | |
577 | ) | |
578 | ||
579 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG(r, _, arg) \ | |
580 | , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME( \ | |
581 | BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \ | |
582 | )& BOOST_PARAMETER_FN_ARG_KEYWORD(arg) | |
583 | ||
584 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER(r, _, arg) \ | |
585 | , BOOST_PARAMETER_FN_ARG_KEYWORD(arg) | |
586 | ||
587 | // Produces a name for the dispatch functions. | |
588 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name) \ | |
589 | BOOST_PP_CAT( \ | |
590 | boost_param_default_ \ | |
591 | , BOOST_PP_CAT(__LINE__, BOOST_PARAMETER_MEMBER_FUNCTION_NAME(name)) \ | |
592 | ) | |
593 | ||
594 | // Helper macro used below to produce lists based on the keyword argument | |
595 | // names. macro is applied to every element. n is the number of | |
596 | // optional arguments that should be included. | |
597 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS(macro, n, split_args) \ | |
598 | BOOST_PP_SEQ_FOR_EACH( \ | |
599 | macro \ | |
600 | , ~ \ | |
601 | , BOOST_PP_TUPLE_ELEM(4,1,split_args) \ | |
602 | ) \ | |
603 | BOOST_PP_SEQ_FOR_EACH( \ | |
604 | macro \ | |
605 | , ~ \ | |
606 | , BOOST_PP_SEQ_FIRST_N( \ | |
607 | BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), n) \ | |
608 | , BOOST_PP_TUPLE_ELEM(4,3,split_args) \ | |
609 | ) \ | |
610 | ) | |
611 | ||
612 | // Generates a keyword | default expression. | |
613 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT(arg, tag_namespace) \ | |
614 | boost::parameter::keyword< \ | |
615 | tag_namespace::BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \ | |
616 | >::instance | boost::parameter::aux::use_default_tag() | |
617 | ||
618 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_GET_ARG(arg, tag_ns) \ | |
619 | BOOST_PARAMETER_FUNCTION_CAST( \ | |
620 | args[ \ | |
621 | BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT( \ | |
622 | arg, tag_ns \ | |
623 | ) \ | |
624 | ] \ | |
625 | , BOOST_PARAMETER_FN_ARG_PRED(arg) \ | |
626 | , Args \ | |
627 | ) | |
628 | ||
629 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY(name, n, split_args, tag_namespace) \ | |
630 | { \ | |
631 | return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ | |
632 | (ResultType(*)())0 \ | |
633 | , args \ | |
634 | , 0L \ | |
635 | BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
636 | BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER \ | |
637 | , n \ | |
638 | , split_args \ | |
639 | ) \ | |
640 | , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_GET_ARG( \ | |
641 | BOOST_PP_SEQ_ELEM( \ | |
642 | BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), n) \ | |
643 | , BOOST_PP_TUPLE_ELEM(4,3,split_args) \ | |
644 | ) \ | |
645 | , tag_namespace \ | |
646 | ) \ | |
647 | ); \ | |
648 | } | |
649 | ||
650 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_ACTUAL_DEFAULT(arg) \ | |
651 | BOOST_PARAMETER_FUNCTION_CAST( \ | |
652 | boost::parameter::aux::as_lvalue(BOOST_PARAMETER_FN_ARG_DEFAULT(arg), 0L) \ | |
653 | , BOOST_PARAMETER_FN_ARG_PRED(arg) \ | |
654 | , Args \ | |
655 | ) | |
656 | ||
657 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT_BODY(name, n, split_args, tag_ns, const_) \ | |
658 | template < \ | |
659 | class ResultType \ | |
660 | , class Args \ | |
661 | BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
662 | BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \ | |
663 | , BOOST_PP_INC(n) \ | |
664 | , split_args \ | |
665 | ) \ | |
666 | > \ | |
667 | BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \ | |
668 | ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ | |
669 | ResultType(*)() \ | |
670 | , Args const& args \ | |
671 | , long \ | |
672 | BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
673 | BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \ | |
674 | , BOOST_PP_INC(n) \ | |
675 | , split_args \ | |
676 | ) \ | |
677 | , boost::parameter::aux::use_default_tag \ | |
678 | ) BOOST_PP_EXPR_IF(const_, const) \ | |
679 | { \ | |
680 | return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ | |
681 | (ResultType(*)())0 \ | |
682 | , args \ | |
683 | , 0L \ | |
684 | BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
685 | BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER \ | |
686 | , BOOST_PP_INC(n) \ | |
687 | , split_args \ | |
688 | ) \ | |
689 | , BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_ACTUAL_DEFAULT( \ | |
690 | BOOST_PP_SEQ_ELEM( \ | |
691 | BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), BOOST_PP_INC(n)) \ | |
692 | , BOOST_PP_TUPLE_ELEM(4,3,split_args) \ | |
693 | ) \ | |
694 | ) \ | |
695 | ); \ | |
696 | } | |
697 | ||
698 | // Produces a forwarding layer in the default evaluation machine. | |
699 | // | |
700 | // data is a tuple: | |
701 | // | |
702 | // (name, split_args) | |
703 | // | |
704 | // Where name is the base name of the function, and split_args is a tuple: | |
705 | // | |
706 | // (required_count, required_args, optional_count, required_args) | |
707 | // | |
708 | ||
709 | ||
710 | // defines the actual function body for BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION below. | |
711 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION0(z, n, data) \ | |
712 | template < \ | |
713 | class ResultType \ | |
714 | , class Args \ | |
715 | BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
716 | BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \ | |
717 | , n \ | |
718 | , BOOST_PP_TUPLE_ELEM(5,1,data) \ | |
719 | ) \ | |
720 | > \ | |
721 | BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(BOOST_PP_TUPLE_ELEM(5,0,data)) \ | |
722 | ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(BOOST_PP_TUPLE_ELEM(5,0,data))( \ | |
723 | ResultType(*)() \ | |
724 | , Args const& args \ | |
725 | , int \ | |
726 | BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
727 | BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \ | |
728 | , n \ | |
729 | , BOOST_PP_TUPLE_ELEM(5,1,data) \ | |
730 | ) \ | |
731 | ) BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(5,2,data), const) \ | |
732 | BOOST_PP_IF( \ | |
733 | n \ | |
734 | , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY \ | |
735 | , ; BOOST_PP_TUPLE_EAT(4) \ | |
736 | )( \ | |
737 | BOOST_PP_TUPLE_ELEM(5,0,data) \ | |
738 | , n \ | |
739 | , BOOST_PP_TUPLE_ELEM(5,1,data) \ | |
740 | , BOOST_PP_TUPLE_ELEM(5,3,data) \ | |
741 | ) | |
742 | ||
743 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION(z, n, data) \ | |
744 | BOOST_PP_IF( \ | |
745 | BOOST_PP_AND( \ | |
746 | BOOST_PP_NOT(n) \ | |
747 | , BOOST_PP_TUPLE_ELEM(5,4,data) \ | |
748 | ) \ | |
749 | , BOOST_PP_TUPLE_EAT(3) \ | |
750 | , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION0 \ | |
751 | )(z, n, data) \ | |
752 | BOOST_PP_IF( \ | |
753 | BOOST_PP_EQUAL(n, BOOST_PP_TUPLE_ELEM(4,2,BOOST_PP_TUPLE_ELEM(5,1,data))) \ | |
754 | , BOOST_PP_TUPLE_EAT(5) \ | |
755 | , BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT_BODY \ | |
756 | )( \ | |
757 | BOOST_PP_TUPLE_ELEM(5,0,data) \ | |
758 | , n \ | |
759 | , BOOST_PP_TUPLE_ELEM(5,1,data) \ | |
760 | , BOOST_PP_TUPLE_ELEM(5,3,data) \ | |
761 | , BOOST_PP_TUPLE_ELEM(5,2,data) \ | |
762 | ) | |
763 | ||
764 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_GET_ARG(r, tag_ns, arg) \ | |
765 | , BOOST_PARAMETER_FUNCTION_CAST( \ | |
766 | args[ \ | |
767 | boost::parameter::keyword<tag_ns::BOOST_PARAMETER_FN_ARG_KEYWORD(arg)>::instance \ | |
768 | ] \ | |
769 | , BOOST_PARAMETER_FN_ARG_PRED(arg) \ | |
770 | , Args \ | |
771 | ) | |
772 | ||
773 | // Generates the function template that recives a ArgumentPack, and then | |
774 | // goes on to call the layers of overloads generated by | |
775 | // BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER. | |
776 | # define BOOST_PARAMETER_FUNCTION_INITIAL_DISPATCH_FUNCTION(name, split_args, const_, tag_ns) \ | |
777 | template <class Args> \ | |
778 | typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<Args>::type \ | |
779 | BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \ | |
780 | BOOST_PARAMETER_IMPL(name)(Args const& args) BOOST_PP_EXPR_IF(const_, const) \ | |
781 | { \ | |
782 | return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ | |
783 | (typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<Args>::type(*)())0 \ | |
784 | , args \ | |
785 | , 0L \ | |
786 | \ | |
787 | BOOST_PP_SEQ_FOR_EACH( \ | |
788 | BOOST_PARAMETER_FUNCTION_DEFAULT_GET_ARG \ | |
789 | , tag_ns \ | |
790 | , BOOST_PP_TUPLE_ELEM(4,1,split_args) \ | |
791 | ) \ | |
792 | \ | |
793 | ); \ | |
794 | } | |
795 | ||
796 | // Helper for BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER below. | |
797 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER_AUX( \ | |
798 | name, split_args, skip_fwd_decl, const_, tag_namespace \ | |
799 | ) \ | |
800 | BOOST_PP_REPEAT_FROM_TO( \ | |
801 | 0 \ | |
802 | , BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 2, split_args)) \ | |
803 | , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION \ | |
804 | , (name, split_args, const_, tag_namespace, skip_fwd_decl) \ | |
805 | ) \ | |
806 | \ | |
807 | BOOST_PARAMETER_FUNCTION_INITIAL_DISPATCH_FUNCTION(name, split_args, const_, tag_namespace) \ | |
808 | \ | |
809 | template < \ | |
810 | class ResultType \ | |
811 | , class Args \ | |
812 | BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
813 | BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \ | |
814 | , 0 \ | |
815 | , split_args \ | |
816 | ) \ | |
817 | > \ | |
818 | BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \ | |
819 | ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ | |
820 | ResultType(*)() \ | |
821 | , Args const& \ | |
822 | , int \ | |
823 | BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ | |
824 | BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \ | |
825 | , 0 \ | |
826 | , split_args \ | |
827 | ) \ | |
828 | ) BOOST_PP_EXPR_IF(const_, const) | |
829 | ||
830 | // Generates a bunch of forwarding functions that each extract | |
831 | // one more argument. | |
832 | # define BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, skip_fwd_decl, const_, tag_ns) \ | |
833 | BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER_AUX( \ | |
834 | name, BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args), skip_fwd_decl, const_, tag_ns \ | |
835 | ) | |
836 | /**/ | |
837 | ||
838 | // Defines the result metafunction and the parameters specialization. | |
839 | # define BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ | |
840 | BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args) \ | |
841 | \ | |
842 | BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, name, args) \ | |
843 | BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(name); \ | |
844 | ||
845 | // Helper for BOOST_PARAMETER_FUNCTION below. | |
846 | # define BOOST_PARAMETER_FUNCTION_AUX(result, name, tag_namespace, args) \ | |
847 | BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ | |
848 | BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name); \ | |
849 | \ | |
850 | BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \ | |
851 | result, name, args, 0 \ | |
852 | , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ | |
853 | ) \ | |
854 | \ | |
855 | BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, 0, 0, tag_namespace) | |
856 | ||
857 | // Defines a Boost.Parameter enabled function with the new syntax. | |
858 | # define BOOST_PARAMETER_FUNCTION(result, name, tag_namespace, args) \ | |
859 | BOOST_PARAMETER_FUNCTION_AUX( \ | |
860 | result, name, tag_namespace \ | |
861 | , BOOST_PARAMETER_FLATTEN(3, 2, 3, args) \ | |
862 | ) \ | |
863 | /**/ | |
864 | ||
865 | // Defines a Boost.Parameter enabled function. | |
866 | # define BOOST_PARAMETER_BASIC_FUNCTION_AUX(result, name, tag_namespace, args) \ | |
867 | BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ | |
868 | \ | |
869 | BOOST_PARAMETER_FUNCTION_IMPL_FWD(name) \ | |
870 | \ | |
871 | BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \ | |
872 | result, name, args, 0 \ | |
873 | , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ | |
874 | ) \ | |
875 | \ | |
876 | BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name) | |
877 | ||
878 | # define BOOST_PARAMETER_BASIC_FUNCTION(result, name, tag_namespace, args) \ | |
879 | BOOST_PARAMETER_BASIC_FUNCTION_AUX( \ | |
880 | result, name, tag_namespace \ | |
881 | , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \ | |
882 | ) \ | |
883 | /**/ | |
884 | ||
885 | // Defines a Boost.Parameter enabled member function. | |
886 | # define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX(result, name, tag_namespace, args, const_) \ | |
887 | BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ | |
888 | \ | |
889 | BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \ | |
890 | result, name, args, const_ \ | |
891 | , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ | |
892 | ) \ | |
893 | \ | |
894 | BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name) BOOST_PP_EXPR_IF(const_, const) \ | |
895 | /**/ | |
896 | ||
897 | # define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION(result, name, tag_namespace, args) \ | |
898 | BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \ | |
899 | result, name, tag_namespace \ | |
900 | , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \ | |
901 | , 0 \ | |
902 | ) | |
903 | /**/ | |
904 | ||
905 | # define BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION(result, name, tag_namespace, args) \ | |
906 | BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \ | |
907 | result, name, tag_namespace \ | |
908 | , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \ | |
909 | , 1 \ | |
910 | ) | |
911 | /**/ | |
912 | ||
913 | ||
914 | ||
915 | # define BOOST_PARAMETER_MEMBER_FUNCTION_AUX(result, name, tag_namespace, const_, args) \ | |
916 | BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ | |
917 | \ | |
918 | BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \ | |
919 | result, name, args, const_ \ | |
920 | , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ | |
921 | ) \ | |
922 | \ | |
923 | BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, 1, const_, tag_namespace) | |
924 | ||
925 | // Defines a Boost.Parameter enabled function with the new syntax. | |
926 | # define BOOST_PARAMETER_MEMBER_FUNCTION(result, name, tag_namespace, args) \ | |
927 | BOOST_PARAMETER_MEMBER_FUNCTION_AUX( \ | |
928 | result, name, tag_namespace, 0 \ | |
929 | , BOOST_PARAMETER_FLATTEN(3, 2, 3, args) \ | |
930 | ) \ | |
931 | /**/ | |
932 | ||
933 | # define BOOST_PARAMETER_CONST_MEMBER_FUNCTION(result, name, tag_namespace, args) \ | |
934 | BOOST_PARAMETER_MEMBER_FUNCTION_AUX( \ | |
935 | result, name, tag_namespace, 1 \ | |
936 | , BOOST_PARAMETER_FLATTEN(3, 2, 3, args) \ | |
937 | ) \ | |
938 | /**/ | |
939 | ||
940 | // Defines a Boost.Parameter enabled constructor. | |
941 | ||
942 | # define BOOST_PARAMETER_FUNCTION_ARGUMENT(r, _, i, elem) \ | |
943 | BOOST_PP_COMMA_IF(i) elem& BOOST_PP_CAT(a, i) | |
944 | /**/ | |
945 | ||
946 | # define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00(z, n, r, data, elem) \ | |
947 | BOOST_PP_IF( \ | |
948 | n \ | |
949 | , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z, BOOST_PP_TUPLE_EAT(2) \ | |
950 | )(z, n) \ | |
951 | BOOST_PP_EXPR_IF(BOOST_PP_EQUAL(n,1), explicit) \ | |
952 | BOOST_PP_TUPLE_ELEM(6,2,data)( \ | |
953 | BOOST_PP_IF( \ | |
954 | n \ | |
955 | , BOOST_PP_SEQ_FOR_EACH_I_R \ | |
956 | , BOOST_PP_TUPLE_EAT(4) \ | |
957 | )( \ | |
958 | r \ | |
959 | , BOOST_PARAMETER_FUNCTION_ARGUMENT \ | |
960 | , ~ \ | |
961 | , elem \ | |
962 | ) \ | |
963 | BOOST_PP_IF(n, BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z, BOOST_PP_TUPLE_EAT(4))( \ | |
964 | z \ | |
965 | , BOOST_PP_TUPLE_ELEM(6,3,data) \ | |
966 | , BOOST_PP_CAT(constructor_parameters, __LINE__) \ | |
967 | , n \ | |
968 | ) \ | |
969 | ) \ | |
970 | : BOOST_PARAMETER_PARENTHESIZED_TYPE(BOOST_PP_TUPLE_ELEM(6,3,data)) ( \ | |
971 | BOOST_PP_CAT(constructor_parameters, __LINE__)()( \ | |
972 | BOOST_PP_ENUM_PARAMS_Z(z, n, a) \ | |
973 | ) \ | |
974 | ) \ | |
975 | {} | |
976 | /**/ | |
977 | ||
978 | # define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR0(r, data, elem) \ | |
979 | BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00( \ | |
980 | BOOST_PP_TUPLE_ELEM(6,0,data) \ | |
981 | , BOOST_PP_TUPLE_ELEM(6,1,data) \ | |
982 | , r \ | |
983 | , data \ | |
984 | , elem \ | |
985 | ) | |
986 | /**/ | |
987 | ||
988 | # define BOOST_PARAMETER_FUNCTION_FWD_PRODUCT(r, product) \ | |
989 | (product) | |
990 | /**/ | |
991 | ||
992 | # define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_0(z, n, data) \ | |
993 | BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00( \ | |
994 | z, n, BOOST_PP_DEDUCE_R() \ | |
995 | , (z, n, BOOST_PP_TUPLE_REM(4) data) \ | |
996 | , ~ \ | |
997 | ) | |
998 | /**/ | |
999 | ||
1000 | # define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_N(z, n, data) \ | |
1001 | BOOST_PP_SEQ_FOR_EACH( \ | |
1002 | BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR0 \ | |
1003 | , (z, n, BOOST_PP_TUPLE_REM(4) data) \ | |
1004 | , BOOST_PP_SEQ_FOR_EACH_PRODUCT( \ | |
1005 | BOOST_PARAMETER_FUNCTION_FWD_PRODUCT \ | |
1006 | , BOOST_PP_SEQ_FIRST_N( \ | |
1007 | n, BOOST_PP_TUPLE_ELEM(4,2,data) \ | |
1008 | ) \ | |
1009 | ) \ | |
1010 | ) | |
1011 | /**/ | |
1012 | ||
1013 | # define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR(z, n, data) \ | |
1014 | BOOST_PP_IF( \ | |
1015 | n \ | |
1016 | , BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_N \ | |
1017 | , BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_0 \ | |
1018 | )(z,n,data) \ | |
1019 | /**/ | |
1020 | ||
1021 | # define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS0(class_,base,args,combinations,range) \ | |
1022 | BOOST_PP_REPEAT_FROM_TO( \ | |
1023 | BOOST_PP_TUPLE_ELEM(2,0,range), BOOST_PP_TUPLE_ELEM(2,1,range) \ | |
1024 | , BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR \ | |
1025 | , (class_,base,combinations,BOOST_PP_TUPLE_ELEM(2,1,range)) \ | |
1026 | ) | |
1027 | /**/ | |
1028 | ||
1029 | # define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS(class_,base,args,combinations) \ | |
1030 | BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS0( \ | |
1031 | class_, base, args, combinations, BOOST_PARAMETER_ARITY_RANGE(args) \ | |
1032 | ) | |
1033 | /**/ | |
1034 | ||
1035 | # define BOOST_PARAMETER_CONSTRUCTOR_AUX(class_, base, tag_namespace, args) \ | |
1036 | BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, ctor, args) \ | |
1037 | BOOST_PP_CAT(constructor_parameters, __LINE__); \ | |
1038 | \ | |
1039 | BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS( \ | |
1040 | class_, base, args \ | |
1041 | , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ | |
1042 | ) \ | |
1043 | /**/ | |
1044 | ||
1045 | # define BOOST_PARAMETER_CONSTRUCTOR(class_, base, tag_namespace, args) \ | |
1046 | BOOST_PARAMETER_CONSTRUCTOR_AUX( \ | |
1047 | class_, base, tag_namespace \ | |
1048 | , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \ | |
1049 | ) | |
1050 | /**/ | |
1051 | ||
1052 | # ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING | |
1053 | # define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \ | |
1054 | (BOOST_PP_IF( \ | |
1055 | BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \ | |
1056 | BOOST_PARAMETER_FN_ARG_NAME(elem) \ | |
1057 | ) \ | |
1058 | , (const ParameterArgumentType ## i)(ParameterArgumentType ## i) \ | |
1059 | , (const ParameterArgumentType ## i) \ | |
1060 | )) | |
1061 | // No partial ordering. This feature doesn't work. | |
1062 | # else | |
1063 | # define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \ | |
1064 | (BOOST_PP_IF( \ | |
1065 | BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \ | |
1066 | BOOST_PARAMETER_FN_ARG_NAME(elem) \ | |
1067 | ) \ | |
1068 | , (ParameterArgumentType ## i) \ | |
1069 | , (const ParameterArgumentType ## i) \ | |
1070 | )) | |
1071 | # endif | |
1072 | ||
1073 | # define BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ | |
1074 | BOOST_PP_SEQ_FOR_EACH_I(BOOST_PARAMETER_FUNCTION_FWD_COMBINATION, ~, args) | |
1075 | ||
1076 | #endif // BOOST_PARAMETER_PREPROCESSOR_060206_HPP | |
1077 |