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>
operator ()detail::construct_23             result_type operator ()(A0 &a0) const
24             {
25                 return result_type::make(a0);
26             }
27         };
28         template<typename T, typename A>
29         struct construct_<proto::basic_expr<T, A, 0>, true>
30         {
31             typedef proto::basic_expr<T, A, 0> result_type;
32             template<typename A0>
operator ()detail::construct_33             result_type operator ()(A0 &a0) const
34             {
35                 return result_type::make(a0);
36             }
37         };
38         template<typename Type >
construct()39         Type construct()
40         {
41             return construct_<Type>()();
42         }
43     }
44 
45 
46 
47 
48     template<typename Object >
49     struct make<Object()>
50       : transform<make<Object()> >
51     {
52         template<typename Expr, typename State, typename Data>
53         struct impl : transform_impl<Expr, State, Data>
54         {
55 
56             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
57 
58 
59 
60 
61 
62 
63 
operator ()make::impl64             result_type operator ()(
65                 typename impl::expr_param e
66               , typename impl::state_param s
67               , typename impl::data_param d
68             ) const
69             {
70                 proto::detail::ignore_unused(e);
71                 proto::detail::ignore_unused(s);
72                 proto::detail::ignore_unused(d);
73                 return detail::construct<result_type>();
74             }
75         };
76     };
77     namespace detail
78     {
79         template<
80             template<typename> class R
81             , typename A0
82           , typename Expr, typename State, typename Data
83         >
84         struct make_<
85             R<A0>
86           , Expr, State, Data
87             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
88         >
89           : nested_type_if<
90                 R<typename make_if_<A0, Expr, State, Data> ::type>
91               , (make_if_<A0, Expr, State, Data> ::applied || false)
92             >
93         {};
94         template<
95             template<typename> class R
96             , typename A0
97           , typename Expr, typename State, typename Data
98         >
99         struct make_<
100             noinvoke<R<A0> >
101           , Expr, State, Data
102             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
103         >
104         {
105             typedef R<typename make_if_<A0, Expr, State, Data> ::type> type;
106             static bool const applied = true;
107         };
108         template<typename R , typename A0>
109         struct is_applyable<R(A0)>
110           : mpl::true_
111         {};
112         template<typename R , typename A0>
113         struct is_applyable<R(*)(A0)>
114           : mpl::true_
115         {};
116         template<typename T, typename A>
117         struct construct_<proto::expr<T, A, 1>, true>
118         {
119             typedef proto::expr<T, A, 1> result_type;
120             template<typename A0>
operator ()detail::construct_121             result_type operator ()(A0 &a0) const
122             {
123                 return result_type::make(a0);
124             }
125         };
126         template<typename T, typename A>
127         struct construct_<proto::basic_expr<T, A, 1>, true>
128         {
129             typedef proto::basic_expr<T, A, 1> result_type;
130             template<typename A0>
operator ()detail::construct_131             result_type operator ()(A0 &a0) const
132             {
133                 return result_type::make(a0);
134             }
135         };
136         template<typename Type , typename A0>
137         Type construct(A0 &a0)
138         {
139             return construct_<Type>()(a0);
140         }
141     }
142 
143 
144 
145 
146     template<typename Object , typename A0>
147     struct make<Object(A0)>
148       : transform<make<Object(A0)> >
149     {
150         template<typename Expr, typename State, typename Data>
151         struct impl : transform_impl<Expr, State, Data>
152         {
153 
154             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
155 
156 
157 
158 
159 
160 
161 
operator ()make::impl162             result_type operator ()(
163                 typename impl::expr_param e
164               , typename impl::state_param s
165               , typename impl::data_param d
166             ) const
167             {
168                 proto::detail::ignore_unused(e);
169                 proto::detail::ignore_unused(s);
170                 proto::detail::ignore_unused(d);
171                 return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ));
172             }
173         };
174     };
175     namespace detail
176     {
177         template<
178             template<typename , typename> class R
179             , typename A0 , typename A1
180           , typename Expr, typename State, typename Data
181         >
182         struct make_<
183             R<A0 , A1>
184           , Expr, State, Data
185             BOOST_PROTO_TEMPLATE_ARITY_PARAM(2)
186         >
187           : nested_type_if<
188                 R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type>
189               , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || false)
190             >
191         {};
192         template<
193             template<typename , typename> class R
194             , typename A0 , typename A1
195           , typename Expr, typename State, typename Data
196         >
197         struct make_<
198             noinvoke<R<A0 , A1> >
199           , Expr, State, Data
200             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
201         >
202         {
203             typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type> type;
204             static bool const applied = true;
205         };
206         template<typename R , typename A0 , typename A1>
207         struct is_applyable<R(A0 , A1)>
208           : mpl::true_
209         {};
210         template<typename R , typename A0 , typename A1>
211         struct is_applyable<R(*)(A0 , A1)>
212           : mpl::true_
213         {};
214         template<typename T, typename A>
215         struct construct_<proto::expr<T, A, 2>, true>
216         {
217             typedef proto::expr<T, A, 2> result_type;
218             template<typename A0 , typename A1>
operator ()detail::construct_219             result_type operator ()(A0 &a0 , A1 &a1) const
220             {
221                 return result_type::make(a0 , a1);
222             }
223         };
224         template<typename T, typename A>
225         struct construct_<proto::basic_expr<T, A, 2>, true>
226         {
227             typedef proto::basic_expr<T, A, 2> result_type;
228             template<typename A0 , typename A1>
operator ()detail::construct_229             result_type operator ()(A0 &a0 , A1 &a1) const
230             {
231                 return result_type::make(a0 , a1);
232             }
233         };
234         template<typename Type , typename A0 , typename A1>
235         Type construct(A0 &a0 , A1 &a1)
236         {
237             return construct_<Type>()(a0 , a1);
238         }
239     }
240 
241 
242 
243 
244     template<typename Object , typename A0 , typename A1>
245     struct make<Object(A0 , A1)>
246       : transform<make<Object(A0 , A1)> >
247     {
248         template<typename Expr, typename State, typename Data>
249         struct impl : transform_impl<Expr, State, Data>
250         {
251 
252             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
253 
254 
255 
256 
257 
258 
259 
operator ()make::impl260             result_type operator ()(
261                 typename impl::expr_param e
262               , typename impl::state_param s
263               , typename impl::data_param d
264             ) const
265             {
266                 proto::detail::ignore_unused(e);
267                 proto::detail::ignore_unused(s);
268                 proto::detail::ignore_unused(d);
269                 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) ));
270             }
271         };
272     };
273     namespace detail
274     {
275         template<
276             template<typename , typename , typename> class R
277             , typename A0 , typename A1 , typename A2
278           , typename Expr, typename State, typename Data
279         >
280         struct make_<
281             R<A0 , A1 , A2>
282           , Expr, State, Data
283             BOOST_PROTO_TEMPLATE_ARITY_PARAM(3)
284         >
285           : nested_type_if<
286                 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>
287               , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || false)
288             >
289         {};
290         template<
291             template<typename , typename , typename> class R
292             , typename A0 , typename A1 , typename A2
293           , typename Expr, typename State, typename Data
294         >
295         struct make_<
296             noinvoke<R<A0 , A1 , A2> >
297           , Expr, State, Data
298             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
299         >
300         {
301             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;
302             static bool const applied = true;
303         };
304         template<typename R , typename A0 , typename A1 , typename A2>
305         struct is_applyable<R(A0 , A1 , A2)>
306           : mpl::true_
307         {};
308         template<typename R , typename A0 , typename A1 , typename A2>
309         struct is_applyable<R(*)(A0 , A1 , A2)>
310           : mpl::true_
311         {};
312         template<typename T, typename A>
313         struct construct_<proto::expr<T, A, 3>, true>
314         {
315             typedef proto::expr<T, A, 3> result_type;
316             template<typename A0 , typename A1 , typename A2>
operator ()detail::construct_317             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const
318             {
319                 return result_type::make(a0 , a1 , a2);
320             }
321         };
322         template<typename T, typename A>
323         struct construct_<proto::basic_expr<T, A, 3>, true>
324         {
325             typedef proto::basic_expr<T, A, 3> result_type;
326             template<typename A0 , typename A1 , typename A2>
operator ()detail::construct_327             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const
328             {
329                 return result_type::make(a0 , a1 , a2);
330             }
331         };
332         template<typename Type , typename A0 , typename A1 , typename A2>
333         Type construct(A0 &a0 , A1 &a1 , A2 &a2)
334         {
335             return construct_<Type>()(a0 , a1 , a2);
336         }
337     }
338 
339 
340 
341 
342     template<typename Object , typename A0 , typename A1 , typename A2>
343     struct make<Object(A0 , A1 , A2)>
344       : transform<make<Object(A0 , A1 , A2)> >
345     {
346         template<typename Expr, typename State, typename Data>
347         struct impl : transform_impl<Expr, State, Data>
348         {
349 
350             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
351 
352 
353 
354 
355 
356 
357 
operator ()make::impl358             result_type operator ()(
359                 typename impl::expr_param e
360               , typename impl::state_param s
361               , typename impl::data_param d
362             ) const
363             {
364                 proto::detail::ignore_unused(e);
365                 proto::detail::ignore_unused(s);
366                 proto::detail::ignore_unused(d);
367                 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) ));
368             }
369         };
370     };
371     namespace detail
372     {
373         template<
374             template<typename , typename , typename , typename> class R
375             , typename A0 , typename A1 , typename A2 , typename A3
376           , typename Expr, typename State, typename Data
377         >
378         struct make_<
379             R<A0 , A1 , A2 , A3>
380           , Expr, State, Data
381             BOOST_PROTO_TEMPLATE_ARITY_PARAM(4)
382         >
383           : nested_type_if<
384                 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>
385               , (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)
386             >
387         {};
388         template<
389             template<typename , typename , typename , typename> class R
390             , typename A0 , typename A1 , typename A2 , typename A3
391           , typename Expr, typename State, typename Data
392         >
393         struct make_<
394             noinvoke<R<A0 , A1 , A2 , A3> >
395           , Expr, State, Data
396             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
397         >
398         {
399             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;
400             static bool const applied = true;
401         };
402         template<typename R , typename A0 , typename A1 , typename A2 , typename A3>
403         struct is_applyable<R(A0 , A1 , A2 , A3)>
404           : mpl::true_
405         {};
406         template<typename R , typename A0 , typename A1 , typename A2 , typename A3>
407         struct is_applyable<R(*)(A0 , A1 , A2 , A3)>
408           : mpl::true_
409         {};
410         template<typename T, typename A>
411         struct construct_<proto::expr<T, A, 4>, true>
412         {
413             typedef proto::expr<T, A, 4> result_type;
414             template<typename A0 , typename A1 , typename A2 , typename A3>
operator ()detail::construct_415             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const
416             {
417                 return result_type::make(a0 , a1 , a2 , a3);
418             }
419         };
420         template<typename T, typename A>
421         struct construct_<proto::basic_expr<T, A, 4>, true>
422         {
423             typedef proto::basic_expr<T, A, 4> result_type;
424             template<typename A0 , typename A1 , typename A2 , typename A3>
operator ()detail::construct_425             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const
426             {
427                 return result_type::make(a0 , a1 , a2 , a3);
428             }
429         };
430         template<typename Type , typename A0 , typename A1 , typename A2 , typename A3>
431         Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3)
432         {
433             return construct_<Type>()(a0 , a1 , a2 , a3);
434         }
435     }
436 
437 
438 
439 
440     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
441     struct make<Object(A0 , A1 , A2 , A3)>
442       : transform<make<Object(A0 , A1 , A2 , A3)> >
443     {
444         template<typename Expr, typename State, typename Data>
445         struct impl : transform_impl<Expr, State, Data>
446         {
447 
448             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
449 
450 
451 
452 
453 
454 
455 
operator ()make::impl456             result_type operator ()(
457                 typename impl::expr_param e
458               , typename impl::state_param s
459               , typename impl::data_param d
460             ) const
461             {
462                 proto::detail::ignore_unused(e);
463                 proto::detail::ignore_unused(s);
464                 proto::detail::ignore_unused(d);
465                 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) ));
466             }
467         };
468     };
469     namespace detail
470     {
471         template<
472             template<typename , typename , typename , typename , typename> class R
473             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4
474           , typename Expr, typename State, typename Data
475         >
476         struct make_<
477             R<A0 , A1 , A2 , A3 , A4>
478           , Expr, State, Data
479             BOOST_PROTO_TEMPLATE_ARITY_PARAM(5)
480         >
481           : nested_type_if<
482                 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>
483               , (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)
484             >
485         {};
486         template<
487             template<typename , typename , typename , typename , typename> class R
488             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4
489           , typename Expr, typename State, typename Data
490         >
491         struct make_<
492             noinvoke<R<A0 , A1 , A2 , A3 , A4> >
493           , Expr, State, Data
494             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
495         >
496         {
497             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;
498             static bool const applied = true;
499         };
500         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
501         struct is_applyable<R(A0 , A1 , A2 , A3 , A4)>
502           : mpl::true_
503         {};
504         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
505         struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4)>
506           : mpl::true_
507         {};
508         template<typename T, typename A>
509         struct construct_<proto::expr<T, A, 5>, true>
510         {
511             typedef proto::expr<T, A, 5> result_type;
512             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
operator ()detail::construct_513             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const
514             {
515                 return result_type::make(a0 , a1 , a2 , a3 , a4);
516             }
517         };
518         template<typename T, typename A>
519         struct construct_<proto::basic_expr<T, A, 5>, true>
520         {
521             typedef proto::basic_expr<T, A, 5> result_type;
522             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
operator ()detail::construct_523             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const
524             {
525                 return result_type::make(a0 , a1 , a2 , a3 , a4);
526             }
527         };
528         template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
529         Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4)
530         {
531             return construct_<Type>()(a0 , a1 , a2 , a3 , a4);
532         }
533     }
534 
535 
536 
537 
538     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
539     struct make<Object(A0 , A1 , A2 , A3 , A4)>
540       : transform<make<Object(A0 , A1 , A2 , A3 , A4)> >
541     {
542         template<typename Expr, typename State, typename Data>
543         struct impl : transform_impl<Expr, State, Data>
544         {
545 
546             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
547 
548 
549 
550 
551 
552 
553 
operator ()make::impl554             result_type operator ()(
555                 typename impl::expr_param e
556               , typename impl::state_param s
557               , typename impl::data_param d
558             ) const
559             {
560                 proto::detail::ignore_unused(e);
561                 proto::detail::ignore_unused(s);
562                 proto::detail::ignore_unused(d);
563                 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) ));
564             }
565         };
566     };
567     namespace detail
568     {
569         template<
570             template<typename , typename , typename , typename , typename , typename> class R
571             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
572           , typename Expr, typename State, typename Data
573         >
574         struct make_<
575             R<A0 , A1 , A2 , A3 , A4 , A5>
576           , Expr, State, Data
577             BOOST_PROTO_TEMPLATE_ARITY_PARAM(6)
578         >
579           : nested_type_if<
580                 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>
581               , (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)
582             >
583         {};
584         template<
585             template<typename , typename , typename , typename , typename , typename> class R
586             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
587           , typename Expr, typename State, typename Data
588         >
589         struct make_<
590             noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5> >
591           , Expr, State, Data
592             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
593         >
594         {
595             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;
596             static bool const applied = true;
597         };
598         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
599         struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5)>
600           : mpl::true_
601         {};
602         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
603         struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5)>
604           : mpl::true_
605         {};
606         template<typename T, typename A>
607         struct construct_<proto::expr<T, A, 6>, true>
608         {
609             typedef proto::expr<T, A, 6> result_type;
610             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
operator ()detail::construct_611             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const
612             {
613                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5);
614             }
615         };
616         template<typename T, typename A>
617         struct construct_<proto::basic_expr<T, A, 6>, true>
618         {
619             typedef proto::basic_expr<T, A, 6> result_type;
620             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
operator ()detail::construct_621             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const
622             {
623                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5);
624             }
625         };
626         template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
627         Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5)
628         {
629             return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5);
630         }
631     }
632 
633 
634 
635 
636     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
637     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5)>
638       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5)> >
639     {
640         template<typename Expr, typename State, typename Data>
641         struct impl : transform_impl<Expr, State, Data>
642         {
643 
644             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
645 
646 
647 
648 
649 
650 
651 
operator ()make::impl652             result_type operator ()(
653                 typename impl::expr_param e
654               , typename impl::state_param s
655               , typename impl::data_param d
656             ) const
657             {
658                 proto::detail::ignore_unused(e);
659                 proto::detail::ignore_unused(s);
660                 proto::detail::ignore_unused(d);
661                 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) ));
662             }
663         };
664     };
665     namespace detail
666     {
667         template<
668             template<typename , typename , typename , typename , typename , typename , typename> class R
669             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
670           , typename Expr, typename State, typename Data
671         >
672         struct make_<
673             R<A0 , A1 , A2 , A3 , A4 , A5 , A6>
674           , Expr, State, Data
675             BOOST_PROTO_TEMPLATE_ARITY_PARAM(7)
676         >
677           : nested_type_if<
678                 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>
679               , (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)
680             >
681         {};
682         template<
683             template<typename , typename , typename , typename , typename , typename , typename> class R
684             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
685           , typename Expr, typename State, typename Data
686         >
687         struct make_<
688             noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6> >
689           , Expr, State, Data
690             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
691         >
692         {
693             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;
694             static bool const applied = true;
695         };
696         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
697         struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
698           : mpl::true_
699         {};
700         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
701         struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
702           : mpl::true_
703         {};
704         template<typename T, typename A>
705         struct construct_<proto::expr<T, A, 7>, true>
706         {
707             typedef proto::expr<T, A, 7> result_type;
708             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
operator ()detail::construct_709             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const
710             {
711                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6);
712             }
713         };
714         template<typename T, typename A>
715         struct construct_<proto::basic_expr<T, A, 7>, true>
716         {
717             typedef proto::basic_expr<T, A, 7> result_type;
718             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
operator ()detail::construct_719             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const
720             {
721                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6);
722             }
723         };
724         template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
725         Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6)
726         {
727             return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6);
728         }
729     }
730 
731 
732 
733 
734     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
735     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
736       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
737     {
738         template<typename Expr, typename State, typename Data>
739         struct impl : transform_impl<Expr, State, Data>
740         {
741 
742             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
743 
744 
745 
746 
747 
748 
749 
operator ()make::impl750             result_type operator ()(
751                 typename impl::expr_param e
752               , typename impl::state_param s
753               , typename impl::data_param d
754             ) const
755             {
756                 proto::detail::ignore_unused(e);
757                 proto::detail::ignore_unused(s);
758                 proto::detail::ignore_unused(d);
759                 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) ));
760             }
761         };
762     };
763     namespace detail
764     {
765         template<
766             template<typename , typename , typename , typename , typename , typename , typename , typename> class R
767             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7
768           , typename Expr, typename State, typename Data
769         >
770         struct make_<
771             R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
772           , Expr, State, Data
773             BOOST_PROTO_TEMPLATE_ARITY_PARAM(8)
774         >
775           : nested_type_if<
776                 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>
777               , (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)
778             >
779         {};
780         template<
781             template<typename , typename , typename , typename , typename , typename , typename , typename> class R
782             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7
783           , typename Expr, typename State, typename Data
784         >
785         struct make_<
786             noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> >
787           , Expr, State, Data
788             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
789         >
790         {
791             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;
792             static bool const applied = true;
793         };
794         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
795         struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
796           : mpl::true_
797         {};
798         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
799         struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
800           : mpl::true_
801         {};
802         template<typename T, typename A>
803         struct construct_<proto::expr<T, A, 8>, true>
804         {
805             typedef proto::expr<T, A, 8> result_type;
806             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
operator ()detail::construct_807             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const
808             {
809                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
810             }
811         };
812         template<typename T, typename A>
813         struct construct_<proto::basic_expr<T, A, 8>, true>
814         {
815             typedef proto::basic_expr<T, A, 8> result_type;
816             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
operator ()detail::construct_817             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const
818             {
819                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
820             }
821         };
822         template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
823         Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7)
824         {
825             return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
826         }
827     }
828 
829 
830 
831 
832     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
833     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
834       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
835     {
836         template<typename Expr, typename State, typename Data>
837         struct impl : transform_impl<Expr, State, Data>
838         {
839 
840             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
841 
842 
843 
844 
845 
846 
847 
operator ()make::impl848             result_type operator ()(
849                 typename impl::expr_param e
850               , typename impl::state_param s
851               , typename impl::data_param d
852             ) const
853             {
854                 proto::detail::ignore_unused(e);
855                 proto::detail::ignore_unused(s);
856                 proto::detail::ignore_unused(d);
857                 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) ));
858             }
859         };
860     };
861     namespace detail
862     {
863         template<
864             template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
865             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8
866           , typename Expr, typename State, typename Data
867         >
868         struct make_<
869             R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
870           , Expr, State, Data
871             BOOST_PROTO_TEMPLATE_ARITY_PARAM(9)
872         >
873           : nested_type_if<
874                 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>
875               , (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)
876             >
877         {};
878         template<
879             template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
880             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8
881           , typename Expr, typename State, typename Data
882         >
883         struct make_<
884             noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> >
885           , Expr, State, Data
886             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
887         >
888         {
889             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;
890             static bool const applied = true;
891         };
892         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
893         struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
894           : mpl::true_
895         {};
896         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
897         struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
898           : mpl::true_
899         {};
900         template<typename T, typename A>
901         struct construct_<proto::expr<T, A, 9>, true>
902         {
903             typedef proto::expr<T, A, 9> result_type;
904             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
operator ()detail::construct_905             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const
906             {
907                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
908             }
909         };
910         template<typename T, typename A>
911         struct construct_<proto::basic_expr<T, A, 9>, true>
912         {
913             typedef proto::basic_expr<T, A, 9> result_type;
914             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
operator ()detail::construct_915             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const
916             {
917                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
918             }
919         };
920         template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
921         Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8)
922         {
923             return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
924         }
925     }
926 
927 
928 
929 
930     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
931     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
932       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
933     {
934         template<typename Expr, typename State, typename Data>
935         struct impl : transform_impl<Expr, State, Data>
936         {
937 
938             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
939 
940 
941 
942 
943 
944 
945 
operator ()make::impl946             result_type operator ()(
947                 typename impl::expr_param e
948               , typename impl::state_param s
949               , typename impl::data_param d
950             ) const
951             {
952                 proto::detail::ignore_unused(e);
953                 proto::detail::ignore_unused(s);
954                 proto::detail::ignore_unused(d);
955                 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) ));
956             }
957         };
958     };
959     namespace detail
960     {
961         template<
962             template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
963             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
964           , typename Expr, typename State, typename Data
965         >
966         struct make_<
967             R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>
968           , Expr, State, Data
969             BOOST_PROTO_TEMPLATE_ARITY_PARAM(10)
970         >
971           : nested_type_if<
972                 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>
973               , (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)
974             >
975         {};
976         template<
977             template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
978             , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
979           , typename Expr, typename State, typename Data
980         >
981         struct make_<
982             noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> >
983           , Expr, State, Data
984             BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
985         >
986         {
987             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;
988             static bool const applied = true;
989         };
990         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
991         struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
992           : mpl::true_
993         {};
994         template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
995         struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
996           : mpl::true_
997         {};
998         template<typename T, typename A>
999         struct construct_<proto::expr<T, A, 10>, true>
1000         {
1001             typedef proto::expr<T, A, 10> result_type;
1002             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
operator ()detail::construct_1003             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const
1004             {
1005                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
1006             }
1007         };
1008         template<typename T, typename A>
1009         struct construct_<proto::basic_expr<T, A, 10>, true>
1010         {
1011             typedef proto::basic_expr<T, A, 10> result_type;
1012             template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
operator ()detail::construct_1013             result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const
1014             {
1015                 return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
1016             }
1017         };
1018         template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1019         Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9)
1020         {
1021             return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
1022         }
1023     }
1024 
1025 
1026 
1027 
1028     template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
1029     struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
1030       : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
1031     {
1032         template<typename Expr, typename State, typename Data>
1033         struct impl : transform_impl<Expr, State, Data>
1034         {
1035 
1036             typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
1037 
1038 
1039 
1040 
1041 
1042 
1043 
operator ()make::impl1044             result_type operator ()(
1045                 typename impl::expr_param e
1046               , typename impl::state_param s
1047               , typename impl::data_param d
1048             ) const
1049             {
1050                 proto::detail::ignore_unused(e);
1051                 proto::detail::ignore_unused(s);
1052                 proto::detail::ignore_unused(d);
1053                 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) ));
1054             }
1055         };
1056     };
1057