Publishing R3
[platform/upstream/dldt.git] / inference-engine / thirdparty / clDNN / common / boost / 1.64.0 / include / boost-1_64 / boost / proto / transform / detail / preprocessed / call.hpp
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
88             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
139             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
190             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
241             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
292             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
343             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
394             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     };