1 ///////////////////////////////////////////////////////////////////////////////
2 /// \file make.hpp
3 /// Contains definition of the make<> transform.
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 namespace detail
9 {
10 template<typename R >
11 struct is_applyable<R()>
12 : mpl::true_
13 {};
14 template<typename R >
15 struct is_applyable<R(*)()>
16 : mpl::true_
17 {};
18 template<typename T, typename A>
19 struct construct_<proto::expr<T, A, 0>, true>
20 {
21 typedef proto::expr<T, A, 0> result_type;
22 template<typename A0>
23 BOOST_FORCEINLINE
24 result_type operator ()(A0 &a0) const
25 {
26 return result_type::make(a0);
27 }
28 };
29 template<typename T, typename A>
30 struct construct_<proto::basic_expr<T, A, 0>, true>
31 {
32 typedef proto::basic_expr<T, A, 0> result_type;
33 template<typename A0>
34 BOOST_FORCEINLINE
35 result_type operator ()(A0 &a0) const
36 {
37 return result_type::make(a0);
38 }
39 };
40 template<typename Type >
41 BOOST_FORCEINLINE
42 Type construct()
43 {
44 return construct_<Type>()();
45 }
46 }
47
48
49
50
51 template<typename Object >
52 struct make<Object()>
53 : transform<make<Object()> >
54 {
55 template<typename Expr, typename State, typename Data>
56 struct impl : transform_impl<Expr, State, Data>
57 {
58
59 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
60
61
62
63
64
65
66
67 BOOST_FORCEINLINE
68 result_type operator ()(
69 typename impl::expr_param e
70 , typename impl::state_param s
71 , typename impl::data_param d
72 ) const
73 {
74 proto::detail::ignore_unused(e);
75 proto::detail::ignore_unused(s);
76 proto::detail::ignore_unused(d);
77 return detail::construct<result_type>();
78 }
79 };
80 };
81 namespace detail
82 {
83 template<
84 template<typename> class R
85 , typename A0
86 , typename Expr, typename State, typename Data
87 >
88 struct make_<
89 R<A0>
90 , Expr, State, Data
91 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
92 >
93 : nested_type_if<
94 R<typename make_if_<A0, Expr, State, Data> ::type>
95 , (make_if_<A0, Expr, State, Data> ::applied || false)
96 >
97 {};
98 template<
99 template<typename> class R
100 , typename A0
101 , typename Expr, typename State, typename Data
102 >
103 struct make_<
104 noinvoke<R<A0> >
105 , Expr, State, Data
106 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
107 >
108 {
109 typedef R<typename make_if_<A0, Expr, State, Data> ::type> type;
110 static bool const applied = true;
111 };
112 template<typename R , typename A0>
113 struct is_applyable<R(A0)>
114 : mpl::true_
115 {};
116 template<typename R , typename A0>
117 struct is_applyable<R(*)(A0)>
118 : mpl::true_
119 {};
120 template<typename T, typename A>
121 struct construct_<proto::expr<T, A, 1>, true>
122 {
123 typedef proto::expr<T, A, 1> result_type;
124 template<typename A0>
125 BOOST_FORCEINLINE
126 result_type operator ()(A0 &a0) const
127 {
128 return result_type::make(a0);
129 }
130 };
131 template<typename T, typename A>
132 struct construct_<proto::basic_expr<T, A, 1>, true>
133 {
134 typedef proto::basic_expr<T, A, 1> result_type;
135 template<typename A0>
136 BOOST_FORCEINLINE
137 result_type operator ()(A0 &a0) const
138 {
139 return result_type::make(a0);
140 }
141 };
142 template<typename Type , typename A0>
143 BOOST_FORCEINLINE
144 Type construct(A0 &a0)
145 {
146 return construct_<Type>()(a0);
147 }
148 }
149
150
151
152
153 template<typename Object , typename A0>
154 struct make<Object(A0)>
155 : transform<make<Object(A0)> >
156 {
157 template<typename Expr, typename State, typename Data>
158 struct impl : transform_impl<Expr, State, Data>
159 {
160
161 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
162
163
164
165
166
167
168
169 BOOST_FORCEINLINE
170 result_type operator ()(
171 typename impl::expr_param e
172 , typename impl::state_param s
173 , typename impl::data_param d
174 ) const
175 {
176 proto::detail::ignore_unused(e);
177 proto::detail::ignore_unused(s);
178 proto::detail::ignore_unused(d);
179 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ));
180 }
181 };
182 };
183
184
185
186
187 template<typename Object , typename A0>
188 struct make<Object(A0...)>
189 : transform<make<Object(A0...)> >
190 {
191 template<typename Expr, typename State, typename Data>
192 struct impl
193 : make<
194 typename detail::expand_pattern<
195 proto::arity_of<Expr>::value
196 , A0
197 , detail::expand_pattern_rest_0<
198 Object
199
200 >
201 >::type
202 >::template impl<Expr, State, Data>
203 {};
204 };
205 namespace detail
206 {
207 template<
208 template<typename , typename> class R
209 , typename A0 , typename A1
210 , typename Expr, typename State, typename Data
211 >
212 struct make_<
213 R<A0 , A1>
214 , Expr, State, Data
215 BOOST_PROTO_TEMPLATE_ARITY_PARAM(2)
216 >
217 : nested_type_if<
218 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type>
219 , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || false)
220 >
221 {};
222 template<
223 template<typename , typename> class R
224 , typename A0 , typename A1
225 , typename Expr, typename State, typename Data
226 >
227 struct make_<
228 noinvoke<R<A0 , A1> >
229 , Expr, State, Data
230 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
231 >
232 {
233 typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type> type;
234 static bool const applied = true;
235 };
236 template<typename R , typename A0 , typename A1>
237 struct is_applyable<R(A0 , A1)>
238 : mpl::true_
239 {};
240 template<typename R , typename A0 , typename A1>
241 struct is_applyable<R(*)(A0 , A1)>
242 : mpl::true_
243 {};
244 template<typename T, typename A>
245 struct construct_<proto::expr<T, A, 2>, true>
246 {
247 typedef proto::expr<T, A, 2> result_type;
248 template<typename A0 , typename A1>
249 BOOST_FORCEINLINE
250 result_type operator ()(A0 &a0 , A1 &a1) const
251 {
252 return result_type::make(a0 , a1);
253 }
254 };
255 template<typename T, typename A>
256 struct construct_<proto::basic_expr<T, A, 2>, true>
257 {
258 typedef proto::basic_expr<T, A, 2> result_type;
259 template<typename A0 , typename A1>
260 BOOST_FORCEINLINE
261 result_type operator ()(A0 &a0 , A1 &a1) const
262 {
263 return result_type::make(a0 , a1);
264 }
265 };
266 template<typename Type , typename A0 , typename A1>
267 BOOST_FORCEINLINE
268 Type construct(A0 &a0 , A1 &a1)
269 {
270 return construct_<Type>()(a0 , a1);
271 }
272 }
273
274
275
276
277 template<typename Object , typename A0 , typename A1>
278 struct make<Object(A0 , A1)>
279 : transform<make<Object(A0 , A1)> >
280 {
281 template<typename Expr, typename State, typename Data>
282 struct impl : transform_impl<Expr, State, Data>
283 {
284
285 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
286
287
288
289
290
291
292
293 BOOST_FORCEINLINE
294 result_type operator ()(
295 typename impl::expr_param e
296 , typename impl::state_param s
297 , typename impl::data_param d
298 ) const
299 {
300 proto::detail::ignore_unused(e);
301 proto::detail::ignore_unused(s);
302 proto::detail::ignore_unused(d);
303 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ));
304 }
305 };
306 };
307
308
309
310
311 template<typename Object , typename A0 , typename A1>
312 struct make<Object(A0 , A1...)>
313 : transform<make<Object(A0 , A1...)> >
314 {
315 template<typename Expr, typename State, typename Data>
316 struct impl
317 : make<
318 typename detail::expand_pattern<
319 proto::arity_of<Expr>::value
320 , A1
321 , detail::expand_pattern_rest_1<
322 Object
323 , A0
324 >
325 >::type
326 >::template impl<Expr, State, Data>
327 {};
328 };
329 namespace detail
330 {
331 template<
332 template<typename , typename , typename> class R
333 , typename A0 , typename A1 , typename A2
334 , typename Expr, typename State, typename Data
335 >
336 struct make_<
337 R<A0 , A1 , A2>
338 , Expr, State, Data
339 BOOST_PROTO_TEMPLATE_ARITY_PARAM(3)
340 >
341 : nested_type_if<
342 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type>
343 , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || false)
344 >
345 {};
346 template<
347 template<typename , typename , typename> class R
348 , typename A0 , typename A1 , typename A2
349 , typename Expr, typename State, typename Data
350 >
351 struct make_<
352 noinvoke<R<A0 , A1 , A2> >
353 , Expr, State, Data
354 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
355 >
356 {
357 typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type> type;
358 static bool const applied = true;
359 };
360 template<typename R , typename A0 , typename A1 , typename A2>
361 struct is_applyable<R(A0 , A1 , A2)>
362 : mpl::true_
363 {};
364 template<typename R , typename A0 , typename A1 , typename A2>
365 struct is_applyable<R(*)(A0 , A1 , A2)>
366 : mpl::true_
367 {};
368 template<typename T, typename A>
369 struct construct_<proto::expr<T, A, 3>, true>
370 {
371 typedef proto::expr<T, A, 3> result_type;
372 template<typename A0 , typename A1 , typename A2>
373 BOOST_FORCEINLINE
374 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const
375 {
376 return result_type::make(a0 , a1 , a2);
377 }
378 };
379 template<typename T, typename A>
380 struct construct_<proto::basic_expr<T, A, 3>, true>
381 {
382 typedef proto::basic_expr<T, A, 3> result_type;
383 template<typename A0 , typename A1 , typename A2>
384 BOOST_FORCEINLINE
385 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const
386 {
387 return result_type::make(a0 , a1 , a2);
388 }
389 };
390 template<typename Type , typename A0 , typename A1 , typename A2>
391 BOOST_FORCEINLINE
392 Type construct(A0 &a0 , A1 &a1 , A2 &a2)
393 {
394 return construct_<Type>()(a0 , a1 , a2);
395 }
396 }
397
398
399
400
401 template<typename Object , typename A0 , typename A1 , typename A2>
402 struct make<Object(A0 , A1 , A2)>
403 : transform<make<Object(A0 , A1 , A2)> >
404 {
405 template<typename Expr, typename State, typename Data>
406 struct impl : transform_impl<Expr, State, Data>
407 {
408
409 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
410
411
412
413
414
415
416
417 BOOST_FORCEINLINE
418 result_type operator ()(
419 typename impl::expr_param e
420 , typename impl::state_param s
421 , typename impl::data_param d
422 ) const
423 {
424 proto::detail::ignore_unused(e);
425 proto::detail::ignore_unused(s);
426 proto::detail::ignore_unused(d);
427 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ));
428 }
429 };
430 };
431
432
433
434
435 template<typename Object , typename A0 , typename A1 , typename A2>
436 struct make<Object(A0 , A1 , A2...)>
437 : transform<make<Object(A0 , A1 , A2...)> >
438 {
439 template<typename Expr, typename State, typename Data>
440 struct impl
441 : make<
442 typename detail::expand_pattern<
443 proto::arity_of<Expr>::value
444 , A2
445 , detail::expand_pattern_rest_2<
446 Object
447 , A0 , A1
448 >
449 >::type
450 >::template impl<Expr, State, Data>
451 {};
452 };
453 namespace detail
454 {
455 template<
456 template<typename , typename , typename , typename> class R
457 , typename A0 , typename A1 , typename A2 , typename A3
458 , typename Expr, typename State, typename Data
459 >
460 struct make_<
461 R<A0 , A1 , A2 , A3>
462 , Expr, State, Data
463 BOOST_PROTO_TEMPLATE_ARITY_PARAM(4)
464 >
465 : nested_type_if<
466 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type>
467 , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || false)
468 >
469 {};
470 template<
471 template<typename , typename , typename , typename> class R
472 , typename A0 , typename A1 , typename A2 , typename A3
473 , typename Expr, typename State, typename Data
474 >
475 struct make_<
476 noinvoke<R<A0 , A1 , A2 , A3> >
477 , Expr, State, Data
478 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
479 >
480 {
481 typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type> type;
482 static bool const applied = true;
483 };
484 template<typename R , typename A0 , typename A1 , typename A2 , typename A3>
485 struct is_applyable<R(A0 , A1 , A2 , A3)>
486 : mpl::true_
487 {};
488 template<typename R , typename A0 , typename A1 , typename A2 , typename A3>
489 struct is_applyable<R(*)(A0 , A1 , A2 , A3)>
490 : mpl::true_
491 {};
492 template<typename T, typename A>
493 struct construct_<proto::expr<T, A, 4>, true>
494 {
495 typedef proto::expr<T, A, 4> result_type;
496 template<typename A0 , typename A1 , typename A2 , typename A3>
497 BOOST_FORCEINLINE
498 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const
499 {
500 return result_type::make(a0 , a1 , a2 , a3);
501 }
502 };
503 template<typename T, typename A>
504 struct construct_<proto::basic_expr<T, A, 4>, true>
505 {
506 typedef proto::basic_expr<T, A, 4> result_type;
507 template<typename A0 , typename A1 , typename A2 , typename A3>
508 BOOST_FORCEINLINE
509 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const
510 {
511 return result_type::make(a0 , a1 , a2 , a3);
512 }
513 };
514 template<typename Type , typename A0 , typename A1 , typename A2 , typename A3>
515 BOOST_FORCEINLINE
516 Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3)
517 {
518 return construct_<Type>()(a0 , a1 , a2 , a3);
519 }
520 }
521
522
523
524
525 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
526 struct make<Object(A0 , A1 , A2 , A3)>
527 : transform<make<Object(A0 , A1 , A2 , A3)> >
528 {
529 template<typename Expr, typename State, typename Data>
530 struct impl : transform_impl<Expr, State, Data>
531 {
532
533 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
534
535
536
537
538
539
540
541 BOOST_FORCEINLINE
542 result_type operator ()(
543 typename impl::expr_param e
544 , typename impl::state_param s
545 , typename impl::data_param d
546 ) const
547 {
548 proto::detail::ignore_unused(e);
549 proto::detail::ignore_unused(s);
550 proto::detail::ignore_unused(d);
551 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ));
552 }
553 };
554 };
555
556
557
558
559 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
560 struct make<Object(A0 , A1 , A2 , A3...)>
561 : transform<make<Object(A0 , A1 , A2 , A3...)> >
562 {
563 template<typename Expr, typename State, typename Data>
564 struct impl
565 : make<
566 typename detail::expand_pattern<
567 proto::arity_of<Expr>::value
568 , A3
569 , detail::expand_pattern_rest_3<
570 Object
571 , A0 , A1 , A2
572 >
573 >::type
574 >::template impl<Expr, State, Data>
575 {};
576 };
577 namespace detail
578 {
579 template<
580 template<typename , typename , typename , typename , typename> class R
581 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4
582 , typename Expr, typename State, typename Data
583 >
584 struct make_<
585 R<A0 , A1 , A2 , A3 , A4>
586 , Expr, State, Data
587 BOOST_PROTO_TEMPLATE_ARITY_PARAM(5)
588 >
589 : nested_type_if<
590 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type>
591 , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || false)
592 >
593 {};
594 template<
595 template<typename , typename , typename , typename , typename> class R
596 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4
597 , typename Expr, typename State, typename Data
598 >
599 struct make_<
600 noinvoke<R<A0 , A1 , A2 , A3 , A4> >
601 , Expr, State, Data
602 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
603 >
604 {
605 typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type> type;
606 static bool const applied = true;
607 };
608 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
609 struct is_applyable<R(A0 , A1 , A2 , A3 , A4)>
610 : mpl::true_
611 {};
612 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
613 struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4)>
614 : mpl::true_
615 {};
616 template<typename T, typename A>
617 struct construct_<proto::expr<T, A, 5>, true>
618 {
619 typedef proto::expr<T, A, 5> result_type;
620 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
621 BOOST_FORCEINLINE
622 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const
623 {
624 return result_type::make(a0 , a1 , a2 , a3 , a4);
625 }
626 };
627 template<typename T, typename A>
628 struct construct_<proto::basic_expr<T, A, 5>, true>
629 {
630 typedef proto::basic_expr<T, A, 5> result_type;
631 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
632 BOOST_FORCEINLINE
633 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const
634 {
635 return result_type::make(a0 , a1 , a2 , a3 , a4);
636 }
637 };
638 template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
639 BOOST_FORCEINLINE
640 Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4)
641 {
642 return construct_<Type>()(a0 , a1 , a2 , a3 , a4);
643 }
644 }
645
646
647
648
649 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
650 struct make<Object(A0 , A1 , A2 , A3 , A4)>
651 : transform<make<Object(A0 , A1 , A2 , A3 , A4)> >
652 {
653 template<typename Expr, typename State, typename Data>
654 struct impl : transform_impl<Expr, State, Data>
655 {
656
657 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
658
659
660
661
662
663
664
665 BOOST_FORCEINLINE
666 result_type operator ()(
667 typename impl::expr_param e
668 , typename impl::state_param s
669 , typename impl::data_param d
670 ) const
671 {
672 proto::detail::ignore_unused(e);
673 proto::detail::ignore_unused(s);
674 proto::detail::ignore_unused(d);
675 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ));
676 }
677 };
678 };
679
680
681
682
683 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
684 struct make<Object(A0 , A1 , A2 , A3 , A4...)>
685 : transform<make<Object(A0 , A1 , A2 , A3 , A4...)> >
686 {
687 template<typename Expr, typename State, typename Data>
688 struct impl
689 : make<
690 typename detail::expand_pattern<
691 proto::arity_of<Expr>::value
692 , A4
693 , detail::expand_pattern_rest_4<
694 Object
695 , A0 , A1 , A2 , A3
696 >
697 >::type
698 >::template impl<Expr, State, Data>
699 {};
700 };
701 namespace detail
702 {
703 template<
704 template<typename , typename , typename , typename , typename , typename> class R
705 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
706 , typename Expr, typename State, typename Data
707 >
708 struct make_<
709 R<A0 , A1 , A2 , A3 , A4 , A5>
710 , Expr, State, Data
711 BOOST_PROTO_TEMPLATE_ARITY_PARAM(6)
712 >
713 : nested_type_if<
714 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type>
715 , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || false)
716 >
717 {};
718 template<
719 template<typename , typename , typename , typename , typename , typename> class R
720 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
721 , typename Expr, typename State, typename Data
722 >
723 struct make_<
724 noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5> >
725 , Expr, State, Data
726 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
727 >
728 {
729 typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type> type;
730 static bool const applied = true;
731 };
732 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
733 struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5)>
734 : mpl::true_
735 {};
736 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
737 struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5)>
738 : mpl::true_
739 {};
740 template<typename T, typename A>
741 struct construct_<proto::expr<T, A, 6>, true>
742 {
743 typedef proto::expr<T, A, 6> result_type;
744 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
745 BOOST_FORCEINLINE
746 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const
747 {
748 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5);
749 }
750 };
751 template<typename T, typename A>
752 struct construct_<proto::basic_expr<T, A, 6>, true>
753 {
754 typedef proto::basic_expr<T, A, 6> result_type;
755 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
756 BOOST_FORCEINLINE
757 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const
758 {
759 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5);
760 }
761 };
762 template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
763 BOOST_FORCEINLINE
764 Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5)
765 {
766 return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5);
767 }
768 }
769
770
771
772
773 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
774 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5)>
775 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5)> >
776 {
777 template<typename Expr, typename State, typename Data>
778 struct impl : transform_impl<Expr, State, Data>
779 {
780
781 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
782
783
784
785
786
787
788
789 BOOST_FORCEINLINE
790 result_type operator ()(
791 typename impl::expr_param e
792 , typename impl::state_param s
793 , typename impl::data_param d
794 ) const
795 {
796 proto::detail::ignore_unused(e);
797 proto::detail::ignore_unused(s);
798 proto::detail::ignore_unused(d);
799 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ));
800 }
801 };
802 };
803
804
805
806
807 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
808 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5...)>
809 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5...)> >
810 {
811 template<typename Expr, typename State, typename Data>
812 struct impl
813 : make<
814 typename detail::expand_pattern<
815 proto::arity_of<Expr>::value
816 , A5
817 , detail::expand_pattern_rest_5<
818 Object
819 , A0 , A1 , A2 , A3 , A4
820 >
821 >::type
822 >::template impl<Expr, State, Data>
823 {};
824 };
825 namespace detail
826 {
827 template<
828 template<typename , typename , typename , typename , typename , typename , typename> class R
829 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
830 , typename Expr, typename State, typename Data
831 >
832 struct make_<
833 R<A0 , A1 , A2 , A3 , A4 , A5 , A6>
834 , Expr, State, Data
835 BOOST_PROTO_TEMPLATE_ARITY_PARAM(7)
836 >
837 : nested_type_if<
838 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type>
839 , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || false)
840 >
841 {};
842 template<
843 template<typename , typename , typename , typename , typename , typename , typename> class R
844 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
845 , typename Expr, typename State, typename Data
846 >
847 struct make_<
848 noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6> >
849 , Expr, State, Data
850 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
851 >
852 {
853 typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type> type;
854 static bool const applied = true;
855 };
856 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
857 struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
858 : mpl::true_
859 {};
860 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
861 struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
862 : mpl::true_
863 {};
864 template<typename T, typename A>
865 struct construct_<proto::expr<T, A, 7>, true>
866 {
867 typedef proto::expr<T, A, 7> result_type;
868 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
869 BOOST_FORCEINLINE
870 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const
871 {
872 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6);
873 }
874 };
875 template<typename T, typename A>
876 struct construct_<proto::basic_expr<T, A, 7>, true>
877 {
878 typedef proto::basic_expr<T, A, 7> result_type;
879 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
880 BOOST_FORCEINLINE
881 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const
882 {
883 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6);
884 }
885 };
886 template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
887 BOOST_FORCEINLINE
888 Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6)
889 {
890 return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6);
891 }
892 }
893
894
895
896
897 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
898 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
899 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
900 {
901 template<typename Expr, typename State, typename Data>
902 struct impl : transform_impl<Expr, State, Data>
903 {
904
905 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
906
907
908
909
910
911
912
913 BOOST_FORCEINLINE
914 result_type operator ()(
915 typename impl::expr_param e
916 , typename impl::state_param s
917 , typename impl::data_param d
918 ) const
919 {
920 proto::detail::ignore_unused(e);
921 proto::detail::ignore_unused(s);
922 proto::detail::ignore_unused(d);
923 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ));
924 }
925 };
926 };
927
928
929
930
931 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
932 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)>
933 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> >
934 {
935 template<typename Expr, typename State, typename Data>
936 struct impl
937 : make<
938 typename detail::expand_pattern<
939 proto::arity_of<Expr>::value
940 , A6
941 , detail::expand_pattern_rest_6<
942 Object
943 , A0 , A1 , A2 , A3 , A4 , A5
944 >
945 >::type
946 >::template impl<Expr, State, Data>
947 {};
948 };
949 namespace detail
950 {
951 template<
952 template<typename , typename , typename , typename , typename , typename , typename , typename> class R
953 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7
954 , typename Expr, typename State, typename Data
955 >
956 struct make_<
957 R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
958 , Expr, State, Data
959 BOOST_PROTO_TEMPLATE_ARITY_PARAM(8)
960 >
961 : nested_type_if<
962 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type>
963 , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || false)
964 >
965 {};
966 template<
967 template<typename , typename , typename , typename , typename , typename , typename , typename> class R
968 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7
969 , typename Expr, typename State, typename Data
970 >
971 struct make_<
972 noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> >
973 , Expr, State, Data
974 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
975 >
976 {
977 typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type> type;
978 static bool const applied = true;
979 };
980 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
981 struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
982 : mpl::true_
983 {};
984 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
985 struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
986 : mpl::true_
987 {};
988 template<typename T, typename A>
989 struct construct_<proto::expr<T, A, 8>, true>
990 {
991 typedef proto::expr<T, A, 8> result_type;
992 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
993 BOOST_FORCEINLINE
994 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const
995 {
996 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
997 }
998 };
999 template<typename T, typename A>
1000 struct construct_<proto::basic_expr<T, A, 8>, true>
1001 {
1002 typedef proto::basic_expr<T, A, 8> result_type;
1003 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1004 BOOST_FORCEINLINE
1005 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const
1006 {
1007 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
1008 }
1009 };
1010 template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1011 BOOST_FORCEINLINE
1012 Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7)
1013 {
1014 return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
1015 }
1016 }
1017
1018
1019
1020
1021 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1022 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
1023 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
1024 {
1025 template<typename Expr, typename State, typename Data>
1026 struct impl : transform_impl<Expr, State, Data>
1027 {
1028
1029 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
1030
1031
1032
1033
1034
1035
1036
1037 BOOST_FORCEINLINE
1038 result_type operator ()(
1039 typename impl::expr_param e
1040 , typename impl::state_param s
1041 , typename impl::data_param d
1042 ) const
1043 {
1044 proto::detail::ignore_unused(e);
1045 proto::detail::ignore_unused(s);
1046 proto::detail::ignore_unused(d);
1047 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ));
1048 }
1049 };
1050 };
1051
1052
1053
1054
1055 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
1056 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)>
1057 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> >
1058 {
1059 template<typename Expr, typename State, typename Data>
1060 struct impl
1061 : make<
1062 typename detail::expand_pattern<
1063 proto::arity_of<Expr>::value
1064 , A7
1065 , detail::expand_pattern_rest_7<
1066 Object
1067 , A0 , A1 , A2 , A3 , A4 , A5 , A6
1068 >
1069 >::type
1070 >::template impl<Expr, State, Data>
1071 {};
1072 };
1073 namespace detail
1074 {
1075 template<
1076 template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
1077 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8
1078 , typename Expr, typename State, typename Data
1079 >
1080 struct make_<
1081 R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
1082 , Expr, State, Data
1083 BOOST_PROTO_TEMPLATE_ARITY_PARAM(9)
1084 >
1085 : nested_type_if<
1086 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type>
1087 , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || make_if_<A8, Expr, State, Data> ::applied || false)
1088 >
1089 {};
1090 template<
1091 template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
1092 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8
1093 , typename Expr, typename State, typename Data
1094 >
1095 struct make_<
1096 noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> >
1097 , Expr, State, Data
1098 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
1099 >
1100 {
1101 typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type> type;
1102 static bool const applied = true;
1103 };
1104 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1105 struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
1106 : mpl::true_
1107 {};
1108 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1109 struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
1110 : mpl::true_
1111 {};
1112 template<typename T, typename A>
1113 struct construct_<proto::expr<T, A, 9>, true>
1114 {
1115 typedef proto::expr<T, A, 9> result_type;
1116 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1117 BOOST_FORCEINLINE
1118 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const
1119 {
1120 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
1121 }
1122 };
1123 template<typename T, typename A>
1124 struct construct_<proto::basic_expr<T, A, 9>, true>
1125 {
1126 typedef proto::basic_expr<T, A, 9> result_type;
1127 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1128 BOOST_FORCEINLINE
1129 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const
1130 {
1131 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
1132 }
1133 };
1134 template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1135 BOOST_FORCEINLINE
1136 Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8)
1137 {
1138 return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
1139 }
1140 }
1141
1142
1143
1144
1145 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1146 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
1147 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
1148 {
1149 template<typename Expr, typename State, typename Data>
1150 struct impl : transform_impl<Expr, State, Data>
1151 {
1152
1153 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
1154
1155
1156
1157
1158
1159
1160
1161 BOOST_FORCEINLINE
1162 result_type operator ()(
1163 typename impl::expr_param e
1164 , typename impl::state_param s
1165 , typename impl::data_param d
1166 ) const
1167 {
1168 proto::detail::ignore_unused(e);
1169 proto::detail::ignore_unused(s);
1170 proto::detail::ignore_unused(d);
1171 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ));
1172 }
1173 };
1174 };
1175
1176
1177
1178
1179 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
1180 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)>
1181 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> >
1182 {
1183 template<typename Expr, typename State, typename Data>
1184 struct impl
1185 : make<
1186 typename detail::expand_pattern<
1187 proto::arity_of<Expr>::value
1188 , A8
1189 , detail::expand_pattern_rest_8<
1190 Object
1191 , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
1192 >
1193 >::type
1194 >::template impl<Expr, State, Data>
1195 {};
1196 };
1197 namespace detail
1198 {
1199 template<
1200 template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
1201 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
1202 , typename Expr, typename State, typename Data
1203 >
1204 struct make_<
1205 R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>
1206 , Expr, State, Data
1207 BOOST_PROTO_TEMPLATE_ARITY_PARAM(10)
1208 >
1209 : nested_type_if<
1210 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type , typename make_if_<A9, Expr, State, Data> ::type>
1211 , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || make_if_<A8, Expr, State, Data> ::applied || make_if_<A9, Expr, State, Data> ::applied || false)
1212 >
1213 {};
1214 template<
1215 template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
1216 , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
1217 , typename Expr, typename State, typename Data
1218 >
1219 struct make_<
1220 noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> >
1221 , Expr, State, Data
1222 BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
1223 >
1224 {
1225 typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type , typename make_if_<A9, Expr, State, Data> ::type> type;
1226 static bool const applied = true;
1227 };
1228 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1229 struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
1230 : mpl::true_
1231 {};
1232 template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1233 struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
1234 : mpl::true_
1235 {};
1236 template<typename T, typename A>
1237 struct construct_<proto::expr<T, A, 10>, true>
1238 {
1239 typedef proto::expr<T, A, 10> result_type;
1240 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1241 BOOST_FORCEINLINE
1242 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const
1243 {
1244 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
1245 }
1246 };
1247 template<typename T, typename A>
1248 struct construct_<proto::basic_expr<T, A, 10>, true>
1249 {
1250 typedef proto::basic_expr<T, A, 10> result_type;
1251 template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1252 BOOST_FORCEINLINE
1253 result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const
1254 {
1255 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
1256 }
1257 };
1258 template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1259 BOOST_FORCEINLINE
1260 Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9)
1261 {
1262 return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
1263 }
1264 }
1265
1266
1267
1268
1269 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1270 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
1271 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
1272 {
1273 template<typename Expr, typename State, typename Data>
1274 struct impl : transform_impl<Expr, State, Data>
1275 {
1276
1277 typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
1278
1279
1280
1281
1282
1283
1284
1285 BOOST_FORCEINLINE
1286 result_type operator ()(
1287 typename impl::expr_param e
1288 , typename impl::state_param s
1289 , typename impl::data_param d
1290 ) const
1291 {
1292 proto::detail::ignore_unused(e);
1293 proto::detail::ignore_unused(s);
1294 proto::detail::ignore_unused(d);
1295 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) ));
1296 }
1297 };
1298 };
1299
1300
1301
1302
1303 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1304 struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)>
1305 : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> >
1306 {
1307 template<typename Expr, typename State, typename Data>
1308 struct impl
1309 : make<
1310 typename detail::expand_pattern<
1311 proto::arity_of<Expr>::value
1312 , A9
1313 , detail::expand_pattern_rest_9<
1314 Object
1315 , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
1316 >
1317 >::type
1318 >::template impl<Expr, State, Data>
1319 {};
1320 };
1321