]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /////////////////////////////////////////////////////////////////////////////// |
2 | /// \file make_expr_.hpp | |
3 | /// Contains definition of make_expr_\<\> class template. | |
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 | template< | |
9 | typename Tag | |
10 | , typename Domain | |
11 | , typename A0 = void , typename A1 = void , typename A2 = void , typename A3 = void , typename A4 = void , typename A5 = void , typename A6 = void , typename A7 = void , typename A8 = void , typename A9 = void | |
12 | , typename _ = void | |
13 | > | |
14 | struct make_expr_ | |
15 | {}; | |
16 | template<typename Domain, typename A> | |
17 | struct make_expr_<tag::terminal, Domain, A | |
18 | , void , void , void , void , void , void , void , void , void , void> | |
19 | { | |
20 | typedef typename proto::detail::protoify<A, Domain>::result_type result_type; | |
21 | BOOST_FORCEINLINE | |
22 | result_type operator()(typename add_reference<A>::type a) const | |
23 | { | |
24 | return proto::detail::protoify<A, Domain>()(a); | |
25 | } | |
26 | }; | |
27 | template<typename A> | |
28 | struct make_expr_<tag::terminal, deduce_domain, A | |
29 | , void , void , void , void , void , void , void , void , void , void> | |
30 | : make_expr_<tag::terminal, default_domain, A> | |
31 | {}; | |
32 | template<typename Tag, typename Domain , typename A0> | |
33 | struct make_expr_<Tag, Domain , A0 | |
34 | , void , void , void , void , void , void , void , void , void, void> | |
35 | { | |
36 | typedef | |
37 | list1< | |
38 | typename boost::proto::detail::protoify< A0 , Domain >::result_type | |
39 | > | |
40 | proto_args; | |
41 | typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; | |
42 | typedef typename Domain::proto_generator proto_generator; | |
43 | typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; | |
44 | BOOST_FORCEINLINE | |
45 | result_type operator()(typename add_reference<A0 >::type a0) const | |
46 | { | |
47 | expr_type const that = { | |
48 | boost::proto::detail::protoify< A0 , Domain >()(a0) | |
49 | }; | |
50 | return proto_generator()(that); | |
51 | } | |
52 | }; | |
53 | template<typename Tag , typename A0> | |
54 | struct make_expr_<Tag, deduce_domain , A0 | |
55 | , void , void , void , void , void , void , void , void , void, void> | |
56 | : make_expr_< | |
57 | Tag | |
58 | , typename deduce_domain1<A0>::type | |
59 | , A0 | |
60 | > | |
61 | {}; | |
62 | template<typename Tag, typename Domain , typename A0 , typename A1> | |
63 | struct make_expr_<Tag, Domain , A0 , A1 | |
64 | , void , void , void , void , void , void , void , void, void> | |
65 | { | |
66 | typedef | |
67 | list2< | |
68 | typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type | |
69 | > | |
70 | proto_args; | |
71 | typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; | |
72 | typedef typename Domain::proto_generator proto_generator; | |
73 | typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; | |
74 | BOOST_FORCEINLINE | |
75 | result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1) const | |
76 | { | |
77 | expr_type const that = { | |
78 | boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) | |
79 | }; | |
80 | return proto_generator()(that); | |
81 | } | |
82 | }; | |
83 | template<typename Tag , typename A0 , typename A1> | |
84 | struct make_expr_<Tag, deduce_domain , A0 , A1 | |
85 | , void , void , void , void , void , void , void , void, void> | |
86 | : make_expr_< | |
87 | Tag | |
88 | , typename deduce_domain2<A0 , A1>::type | |
89 | , A0 , A1 | |
90 | > | |
91 | {}; | |
92 | template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2> | |
93 | struct make_expr_<Tag, Domain , A0 , A1 , A2 | |
94 | , void , void , void , void , void , void , void, void> | |
95 | { | |
96 | typedef | |
97 | list3< | |
98 | typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type | |
99 | > | |
100 | proto_args; | |
101 | typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; | |
102 | typedef typename Domain::proto_generator proto_generator; | |
103 | typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; | |
104 | BOOST_FORCEINLINE | |
105 | result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2) const | |
106 | { | |
107 | expr_type const that = { | |
108 | boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) | |
109 | }; | |
110 | return proto_generator()(that); | |
111 | } | |
112 | }; | |
113 | template<typename Tag , typename A0 , typename A1 , typename A2> | |
114 | struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 | |
115 | , void , void , void , void , void , void , void, void> | |
116 | : make_expr_< | |
117 | Tag | |
118 | , typename deduce_domain3<A0 , A1 , A2>::type | |
119 | , A0 , A1 , A2 | |
120 | > | |
121 | {}; | |
122 | template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3> | |
123 | struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 | |
124 | , void , void , void , void , void , void, void> | |
125 | { | |
126 | typedef | |
127 | list4< | |
128 | typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type | |
129 | > | |
130 | proto_args; | |
131 | typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; | |
132 | typedef typename Domain::proto_generator proto_generator; | |
133 | typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; | |
134 | BOOST_FORCEINLINE | |
135 | result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3) const | |
136 | { | |
137 | expr_type const that = { | |
138 | boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) | |
139 | }; | |
140 | return proto_generator()(that); | |
141 | } | |
142 | }; | |
143 | template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3> | |
144 | struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 | |
145 | , void , void , void , void , void , void, void> | |
146 | : make_expr_< | |
147 | Tag | |
148 | , typename deduce_domain4<A0 , A1 , A2 , A3>::type | |
149 | , A0 , A1 , A2 , A3 | |
150 | > | |
151 | {}; | |
152 | template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> | |
153 | struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 | |
154 | , void , void , void , void , void, void> | |
155 | { | |
156 | typedef | |
157 | list5< | |
158 | typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type | |
159 | > | |
160 | proto_args; | |
161 | typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; | |
162 | typedef typename Domain::proto_generator proto_generator; | |
163 | typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; | |
164 | BOOST_FORCEINLINE | |
165 | result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4) const | |
166 | { | |
167 | expr_type const that = { | |
168 | boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) | |
169 | }; | |
170 | return proto_generator()(that); | |
171 | } | |
172 | }; | |
173 | template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> | |
174 | struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 | |
175 | , void , void , void , void , void, void> | |
176 | : make_expr_< | |
177 | Tag | |
178 | , typename deduce_domain5<A0 , A1 , A2 , A3 , A4>::type | |
179 | , A0 , A1 , A2 , A3 , A4 | |
180 | > | |
181 | {}; | |
182 | template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> | |
183 | struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 | |
184 | , void , void , void , void, void> | |
185 | { | |
186 | typedef | |
187 | list6< | |
188 | typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type | |
189 | > | |
190 | proto_args; | |
191 | typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; | |
192 | typedef typename Domain::proto_generator proto_generator; | |
193 | typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; | |
194 | BOOST_FORCEINLINE | |
195 | result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5) const | |
196 | { | |
197 | expr_type const that = { | |
198 | boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) | |
199 | }; | |
200 | return proto_generator()(that); | |
201 | } | |
202 | }; | |
203 | template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> | |
204 | struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 | |
205 | , void , void , void , void, void> | |
206 | : make_expr_< | |
207 | Tag | |
208 | , typename deduce_domain6<A0 , A1 , A2 , A3 , A4 , A5>::type | |
209 | , A0 , A1 , A2 , A3 , A4 , A5 | |
210 | > | |
211 | {}; | |
212 | template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> | |
213 | struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 | |
214 | , void , void , void, void> | |
215 | { | |
216 | typedef | |
217 | list7< | |
218 | typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type | |
219 | > | |
220 | proto_args; | |
221 | typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; | |
222 | typedef typename Domain::proto_generator proto_generator; | |
223 | typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; | |
224 | BOOST_FORCEINLINE | |
225 | result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6) const | |
226 | { | |
227 | expr_type const that = { | |
228 | boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) | |
229 | }; | |
230 | return proto_generator()(that); | |
231 | } | |
232 | }; | |
233 | template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> | |
234 | struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 | |
235 | , void , void , void, void> | |
236 | : make_expr_< | |
237 | Tag | |
238 | , typename deduce_domain7<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type | |
239 | , A0 , A1 , A2 , A3 , A4 , A5 , A6 | |
240 | > | |
241 | {}; | |
242 | template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> | |
243 | struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 | |
244 | , void , void, void> | |
245 | { | |
246 | typedef | |
247 | list8< | |
248 | typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type | |
249 | > | |
250 | proto_args; | |
251 | typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; | |
252 | typedef typename Domain::proto_generator proto_generator; | |
253 | typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; | |
254 | BOOST_FORCEINLINE | |
255 | result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7) const | |
256 | { | |
257 | expr_type const that = { | |
258 | boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) | |
259 | }; | |
260 | return proto_generator()(that); | |
261 | } | |
262 | }; | |
263 | template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> | |
264 | struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 | |
265 | , void , void, void> | |
266 | : make_expr_< | |
267 | Tag | |
268 | , typename deduce_domain8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type | |
269 | , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 | |
270 | > | |
271 | {}; | |
272 | template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> | |
273 | struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 | |
274 | , void, void> | |
275 | { | |
276 | typedef | |
277 | list9< | |
278 | typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type , typename boost::proto::detail::protoify< A8 , Domain >::result_type | |
279 | > | |
280 | proto_args; | |
281 | typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; | |
282 | typedef typename Domain::proto_generator proto_generator; | |
283 | typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; | |
284 | BOOST_FORCEINLINE | |
285 | result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7 , typename add_reference<A8 >::type a8) const | |
286 | { | |
287 | expr_type const that = { | |
288 | boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) , boost::proto::detail::protoify< A8 , Domain >()(a8) | |
289 | }; | |
290 | return proto_generator()(that); | |
291 | } | |
292 | }; | |
293 | template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> | |
294 | struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 | |
295 | , void, void> | |
296 | : make_expr_< | |
297 | Tag | |
298 | , typename deduce_domain9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type | |
299 | , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 | |
300 | > | |
301 | {}; | |
302 | template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> | |
303 | struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 | |
304 | , void> | |
305 | { | |
306 | typedef | |
307 | list10< | |
308 | typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type , typename boost::proto::detail::protoify< A8 , Domain >::result_type , typename boost::proto::detail::protoify< A9 , Domain >::result_type | |
309 | > | |
310 | proto_args; | |
311 | typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; | |
312 | typedef typename Domain::proto_generator proto_generator; | |
313 | typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; | |
314 | BOOST_FORCEINLINE | |
315 | result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7 , typename add_reference<A8 >::type a8 , typename add_reference<A9 >::type a9) const | |
316 | { | |
317 | expr_type const that = { | |
318 | boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) , boost::proto::detail::protoify< A8 , Domain >()(a8) , boost::proto::detail::protoify< A9 , Domain >()(a9) | |
319 | }; | |
320 | return proto_generator()(that); | |
321 | } | |
322 | }; | |
323 | template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> | |
324 | struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 | |
325 | , void> | |
326 | : make_expr_< | |
327 | Tag | |
328 | , typename deduce_domain10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>::type | |
329 | , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 | |
330 | > | |
331 | {}; |