• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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
operator ()detail::construct_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
operator ()detail::construct_35             result_type operator ()(A0 &a0) const
36             {
37                 return result_type::make(a0);
38             }
39         };
40         template<typename Type >
41         BOOST_FORCEINLINE
construct()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
operator ()make::impl68             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
operator ()detail::construct_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
operator ()detail::construct_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
construct(A0 & a0)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
operator ()make::impl170             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
operator ()detail::construct_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
operator ()detail::construct_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
construct(A0 & a0,A1 & a1)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
operator ()make::impl294             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
operator ()detail::construct_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
operator ()detail::construct_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
construct(A0 & a0,A1 & a1,A2 & a2)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
operator ()make::impl418             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
operator ()detail::construct_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
operator ()detail::construct_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
construct(A0 & a0,A1 & a1,A2 & a2,A3 & a3)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
operator ()make::impl542             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
operator ()detail::construct_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
operator ()detail::construct_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
construct(A0 & a0,A1 & a1,A2 & a2,A3 & a3,A4 & a4)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
operator ()make::impl666             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
operator ()detail::construct_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
operator ()detail::construct_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
construct(A0 & a0,A1 & a1,A2 & a2,A3 & a3,A4 & a4,A5 & a5)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
operator ()make::impl790             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
operator ()detail::construct_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
operator ()detail::construct_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
construct(A0 & a0,A1 & a1,A2 & a2,A3 & a3,A4 & a4,A5 & a5,A6 & a6)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
operator ()make::impl914             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
operator ()detail::construct_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
operator ()detail::construct_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
construct(A0 & a0,A1 & a1,A2 & a2,A3 & a3,A4 & a4,A5 & a5,A6 & a6,A7 & a7)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
operator ()make::impl1038             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
operator ()detail::construct_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
operator ()detail::construct_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
construct(A0 & a0,A1 & a1,A2 & a2,A3 & a3,A4 & a4,A5 & a5,A6 & a6,A7 & a7,A8 & a8)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
operator ()make::impl1162             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
operator ()detail::construct_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
operator ()detail::construct_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
construct(A0 & a0,A1 & a1,A2 & a2,A3 & a3,A4 & a4,A5 & a5,A6 & a6,A7 & a7,A8 & a8,A9 & a9)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
operator ()make::impl1286             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