1     ///////////////////////////////////////////////////////////////////////////////
2     /// \file call.hpp
3     /// Contains definition of the call<> 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 
9 
10 
11     template<typename Fun , typename A0>
12     struct call<Fun(A0...)> : transform<call<Fun(A0...)> >
13     {
14         template<typename Expr, typename State, typename Data>
15         struct impl
16           : call<
17                 typename detail::expand_pattern<
18                     proto::arity_of<Expr>::value
19                   , A0
20                   , detail::expand_pattern_rest_0<
21                         Fun
22 
23                     >
24                 >::type
25             >::template impl<Expr, State, Data>
26         {};
27     };
28 
29 
30 
31     template<typename Fun , typename A0 , typename A1>
32     struct call<Fun(A0 , A1...)> : transform<call<Fun(A0 , A1...)> >
33     {
34         template<typename Expr, typename State, typename Data>
35         struct impl
36           : call<
37                 typename detail::expand_pattern<
38                     proto::arity_of<Expr>::value
39                   , A1
40                   , detail::expand_pattern_rest_1<
41                         Fun
42                         , A0
43                     >
44                 >::type
45             >::template impl<Expr, State, Data>
46         {};
47     };
48 
49 
50 
51     template<typename Fun , typename A0 , typename A1 , typename A2>
52     struct call<Fun(A0 , A1 , A2...)> : transform<call<Fun(A0 , A1 , A2...)> >
53     {
54         template<typename Expr, typename State, typename Data>
55         struct impl
56           : call<
57                 typename detail::expand_pattern<
58                     proto::arity_of<Expr>::value
59                   , A2
60                   , detail::expand_pattern_rest_2<
61                         Fun
62                         , A0 , A1
63                     >
64                 >::type
65             >::template impl<Expr, State, Data>
66         {};
67     };
68 
69 
70 
71     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3>
72     struct call<Fun(A0 , A1 , A2 , A3)> : transform<call<Fun(A0 , A1 , A2 , A3)> >
73     {
74         template<typename Expr, typename State, typename Data>
75         struct impl : transform_impl<Expr, State, Data>
76         {
77             typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3;
78             typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3)> function_traits;
79             typedef typename function_traits::result_type result_type;
80 
81 
82 
83 
84 
85 
86 
87             BOOST_FORCEINLINE
operator ()call::impl88             result_type operator ()(
89                 typename impl::expr_param e
90               , typename impl::state_param s
91               , typename impl::data_param d
92             ) const
93             {
94                 typedef typename function_traits::function_type function_type;
95                 return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)));
96             }
97         };
98     };
99 
100 
101 
102     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3>
103     struct call<Fun(A0 , A1 , A2 , A3...)> : transform<call<Fun(A0 , A1 , A2 , A3...)> >
104     {
105         template<typename Expr, typename State, typename Data>
106         struct impl
107           : call<
108                 typename detail::expand_pattern<
109                     proto::arity_of<Expr>::value
110                   , A3
111                   , detail::expand_pattern_rest_3<
112                         Fun
113                         , A0 , A1 , A2
114                     >
115                 >::type
116             >::template impl<Expr, State, Data>
117         {};
118     };
119 
120 
121 
122     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
123     struct call<Fun(A0 , A1 , A2 , A3 , A4)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4)> >
124     {
125         template<typename Expr, typename State, typename Data>
126         struct impl : transform_impl<Expr, State, Data>
127         {
128             typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4;
129             typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4)> function_traits;
130             typedef typename function_traits::result_type result_type;
131 
132 
133 
134 
135 
136 
137 
138             BOOST_FORCEINLINE
operator ()call::impl139             result_type operator ()(
140                 typename impl::expr_param e
141               , typename impl::state_param s
142               , typename impl::data_param d
143             ) const
144             {
145                 typedef typename function_traits::function_type function_type;
146                 return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)));
147             }
148         };
149     };
150 
151 
152 
153     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
154     struct call<Fun(A0 , A1 , A2 , A3 , A4...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4...)> >
155     {
156         template<typename Expr, typename State, typename Data>
157         struct impl
158           : call<
159                 typename detail::expand_pattern<
160                     proto::arity_of<Expr>::value
161                   , A4
162                   , detail::expand_pattern_rest_4<
163                         Fun
164                         , A0 , A1 , A2 , A3
165                     >
166                 >::type
167             >::template impl<Expr, State, Data>
168         {};
169     };
170 
171 
172 
173     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
174     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5)> >
175     {
176         template<typename Expr, typename State, typename Data>
177         struct impl : transform_impl<Expr, State, Data>
178         {
179             typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5;
180             typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5)> function_traits;
181             typedef typename function_traits::result_type result_type;
182 
183 
184 
185 
186 
187 
188 
189             BOOST_FORCEINLINE
operator ()call::impl190             result_type operator ()(
191                 typename impl::expr_param e
192               , typename impl::state_param s
193               , typename impl::data_param d
194             ) const
195             {
196                 typedef typename function_traits::function_type function_type;
197                 return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)));
198             }
199         };
200     };
201 
202 
203 
204     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
205     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5...)> >
206     {
207         template<typename Expr, typename State, typename Data>
208         struct impl
209           : call<
210                 typename detail::expand_pattern<
211                     proto::arity_of<Expr>::value
212                   , A5
213                   , detail::expand_pattern_rest_5<
214                         Fun
215                         , A0 , A1 , A2 , A3 , A4
216                     >
217                 >::type
218             >::template impl<Expr, State, Data>
219         {};
220     };
221 
222 
223 
224     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
225     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
226     {
227         template<typename Expr, typename State, typename Data>
228         struct impl : transform_impl<Expr, State, Data>
229         {
230             typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6;
231             typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6)> function_traits;
232             typedef typename function_traits::result_type result_type;
233 
234 
235 
236 
237 
238 
239 
240             BOOST_FORCEINLINE
operator ()call::impl241             result_type operator ()(
242                 typename impl::expr_param e
243               , typename impl::state_param s
244               , typename impl::data_param d
245             ) const
246             {
247                 typedef typename function_traits::function_type function_type;
248                 return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)));
249             }
250         };
251     };
252 
253 
254 
255     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
256     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> >
257     {
258         template<typename Expr, typename State, typename Data>
259         struct impl
260           : call<
261                 typename detail::expand_pattern<
262                     proto::arity_of<Expr>::value
263                   , A6
264                   , detail::expand_pattern_rest_6<
265                         Fun
266                         , A0 , A1 , A2 , A3 , A4 , A5
267                     >
268                 >::type
269             >::template impl<Expr, State, Data>
270         {};
271     };
272 
273 
274 
275     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
276     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
277     {
278         template<typename Expr, typename State, typename Data>
279         struct impl : transform_impl<Expr, State, Data>
280         {
281             typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7;
282             typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7)> function_traits;
283             typedef typename function_traits::result_type result_type;
284 
285 
286 
287 
288 
289 
290 
291             BOOST_FORCEINLINE
operator ()call::impl292             result_type operator ()(
293                 typename impl::expr_param e
294               , typename impl::state_param s
295               , typename impl::data_param d
296             ) const
297             {
298                 typedef typename function_traits::function_type function_type;
299                 return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)));
300             }
301         };
302     };
303 
304 
305 
306     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
307     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> >
308     {
309         template<typename Expr, typename State, typename Data>
310         struct impl
311           : call<
312                 typename detail::expand_pattern<
313                     proto::arity_of<Expr>::value
314                   , A7
315                   , detail::expand_pattern_rest_7<
316                         Fun
317                         , A0 , A1 , A2 , A3 , A4 , A5 , A6
318                     >
319                 >::type
320             >::template impl<Expr, State, Data>
321         {};
322     };
323 
324 
325 
326     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
327     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
328     {
329         template<typename Expr, typename State, typename Data>
330         struct impl : transform_impl<Expr, State, Data>
331         {
332             typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; typedef typename when<_, A8>::template impl<Expr, State, Data> a8; typedef typename a8::result_type b8;
333             typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7 , b8)> function_traits;
334             typedef typename function_traits::result_type result_type;
335 
336 
337 
338 
339 
340 
341 
342             BOOST_FORCEINLINE
operator ()call::impl343             result_type operator ()(
344                 typename impl::expr_param e
345               , typename impl::state_param s
346               , typename impl::data_param d
347             ) const
348             {
349                 typedef typename function_traits::function_type function_type;
350                 return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)) , detail::as_lvalue(a8()(e, s, d)));
351             }
352         };
353     };
354 
355 
356 
357     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
358     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> >
359     {
360         template<typename Expr, typename State, typename Data>
361         struct impl
362           : call<
363                 typename detail::expand_pattern<
364                     proto::arity_of<Expr>::value
365                   , A8
366                   , detail::expand_pattern_rest_8<
367                         Fun
368                         , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
369                     >
370                 >::type
371             >::template impl<Expr, State, Data>
372         {};
373     };
374 
375 
376 
377     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
378     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
379     {
380         template<typename Expr, typename State, typename Data>
381         struct impl : transform_impl<Expr, State, Data>
382         {
383             typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; typedef typename when<_, A8>::template impl<Expr, State, Data> a8; typedef typename a8::result_type b8; typedef typename when<_, A9>::template impl<Expr, State, Data> a9; typedef typename a9::result_type b9;
384             typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7 , b8 , b9)> function_traits;
385             typedef typename function_traits::result_type result_type;
386 
387 
388 
389 
390 
391 
392 
393             BOOST_FORCEINLINE
operator ()call::impl394             result_type operator ()(
395                 typename impl::expr_param e
396               , typename impl::state_param s
397               , typename impl::data_param d
398             ) const
399             {
400                 typedef typename function_traits::function_type function_type;
401                 return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)) , detail::as_lvalue(a8()(e, s, d)) , detail::as_lvalue(a9()(e, s, d)));
402             }
403         };
404     };
405 
406 
407 
408     template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
409     struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> >
410     {
411         template<typename Expr, typename State, typename Data>
412         struct impl
413           : call<
414                 typename detail::expand_pattern<
415                     proto::arity_of<Expr>::value
416                   , A9
417                   , detail::expand_pattern_rest_9<
418                         Fun
419                         , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
420                     >
421                 >::type
422             >::template impl<Expr, State, Data>
423         {};
424     };
425