1 ///////////////////////////////////////////////////////////////////////////////
2 /// \file and_n.hpp
3 /// Definitions of and_N, and_impl
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<bool B, typename P0>
12 struct and_2
13 : mpl::bool_<P0::value>
14 {};
15 template<typename P0>
16 struct and_2<false, P0>
17 : mpl::false_
18 {};
19 template<typename G0 , typename G1, typename Expr, typename State, typename Data>
20 struct _and_impl<proto::and_<G0 , G1>, Expr, State, Data>
21 : proto::transform_impl<Expr, State, Data>
22 {
23 typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1;
24 typedef typename Gimpl1::result_type result_type;
25 result_type operator()(
26 typename _and_impl::expr_param e
27 , typename _and_impl::state_param s
28 , typename _and_impl::data_param d
29 ) const
30 {
31
32
33
34
35 Gimpl0()(e,s,d);
36 return Gimpl1()(e,s,d);
37 }
38 };
39
40
41
42 template<bool B, typename P0 , typename P1>
43 struct and_3
44 : and_2<
45 P0::value ,
46 P1
47 >
48 {};
49 template<typename P0 , typename P1>
50 struct and_3<false, P0 , P1>
51 : mpl::false_
52 {};
53 template<typename G0 , typename G1 , typename G2, typename Expr, typename State, typename Data>
54 struct _and_impl<proto::and_<G0 , G1 , G2>, Expr, State, Data>
55 : proto::transform_impl<Expr, State, Data>
56 {
57 typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2;
58 typedef typename Gimpl2::result_type result_type;
59 result_type operator()(
60 typename _and_impl::expr_param e
61 , typename _and_impl::state_param s
62 , typename _and_impl::data_param d
63 ) const
64 {
65
66
67
68
69 Gimpl0()(e,s,d); Gimpl1()(e,s,d);
70 return Gimpl2()(e,s,d);
71 }
72 };
73
74
75
76 template<bool B, typename P0 , typename P1 , typename P2>
77 struct and_4
78 : and_3<
79 P0::value ,
80 P1 , P2
81 >
82 {};
83 template<typename P0 , typename P1 , typename P2>
84 struct and_4<false, P0 , P1 , P2>
85 : mpl::false_
86 {};
87 template<typename G0 , typename G1 , typename G2 , typename G3, typename Expr, typename State, typename Data>
88 struct _and_impl<proto::and_<G0 , G1 , G2 , G3>, Expr, State, Data>
89 : proto::transform_impl<Expr, State, Data>
90 {
91 typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3;
92 typedef typename Gimpl3::result_type result_type;
93 result_type operator()(
94 typename _and_impl::expr_param e
95 , typename _and_impl::state_param s
96 , typename _and_impl::data_param d
97 ) const
98 {
99
100
101
102
103 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d);
104 return Gimpl3()(e,s,d);
105 }
106 };
107
108
109
110 template<bool B, typename P0 , typename P1 , typename P2 , typename P3>
111 struct and_5
112 : and_4<
113 P0::value ,
114 P1 , P2 , P3
115 >
116 {};
117 template<typename P0 , typename P1 , typename P2 , typename P3>
118 struct and_5<false, P0 , P1 , P2 , P3>
119 : mpl::false_
120 {};
121 template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4, typename Expr, typename State, typename Data>
122 struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4>, Expr, State, Data>
123 : proto::transform_impl<Expr, State, Data>
124 {
125 typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4;
126 typedef typename Gimpl4::result_type result_type;
127 result_type operator()(
128 typename _and_impl::expr_param e
129 , typename _and_impl::state_param s
130 , typename _and_impl::data_param d
131 ) const
132 {
133
134
135
136
137 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d);
138 return Gimpl4()(e,s,d);
139 }
140 };
141
142
143
144 template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4>
145 struct and_6
146 : and_5<
147 P0::value ,
148 P1 , P2 , P3 , P4
149 >
150 {};
151 template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4>
152 struct and_6<false, P0 , P1 , P2 , P3 , P4>
153 : mpl::false_
154 {};
155 template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5, typename Expr, typename State, typename Data>
156 struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5>, Expr, State, Data>
157 : proto::transform_impl<Expr, State, Data>
158 {
159 typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5;
160 typedef typename Gimpl5::result_type result_type;
161 result_type operator()(
162 typename _and_impl::expr_param e
163 , typename _and_impl::state_param s
164 , typename _and_impl::data_param d
165 ) const
166 {
167
168
169
170
171 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d);
172 return Gimpl5()(e,s,d);
173 }
174 };
175
176
177
178 template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5>
179 struct and_7
180 : and_6<
181 P0::value ,
182 P1 , P2 , P3 , P4 , P5
183 >
184 {};
185 template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5>
186 struct and_7<false, P0 , P1 , P2 , P3 , P4 , P5>
187 : mpl::false_
188 {};
189 template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6, typename Expr, typename State, typename Data>
190 struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6>, Expr, State, Data>
191 : proto::transform_impl<Expr, State, Data>
192 {
193 typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6;
194 typedef typename Gimpl6::result_type result_type;
195 result_type operator()(
196 typename _and_impl::expr_param e
197 , typename _and_impl::state_param s
198 , typename _and_impl::data_param d
199 ) const
200 {
201
202
203
204
205 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d);
206 return Gimpl6()(e,s,d);
207 }
208 };
209
210
211
212 template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6>
213 struct and_8
214 : and_7<
215 P0::value ,
216 P1 , P2 , P3 , P4 , P5 , P6
217 >
218 {};
219 template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6>
220 struct and_8<false, P0 , P1 , P2 , P3 , P4 , P5 , P6>
221 : mpl::false_
222 {};
223 template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7, typename Expr, typename State, typename Data>
224 struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7>, Expr, State, Data>
225 : proto::transform_impl<Expr, State, Data>
226 {
227 typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7;
228 typedef typename Gimpl7::result_type result_type;
229 result_type operator()(
230 typename _and_impl::expr_param e
231 , typename _and_impl::state_param s
232 , typename _and_impl::data_param d
233 ) const
234 {
235
236
237
238
239 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d);
240 return Gimpl7()(e,s,d);
241 }
242 };
243
244
245
246 template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7>
247 struct and_9
248 : and_8<
249 P0::value ,
250 P1 , P2 , P3 , P4 , P5 , P6 , P7
251 >
252 {};
253 template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7>
254 struct and_9<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7>
255 : mpl::false_
256 {};
257 template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8, typename Expr, typename State, typename Data>
258 struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8>, Expr, State, Data>
259 : proto::transform_impl<Expr, State, Data>
260 {
261 typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8;
262 typedef typename Gimpl8::result_type result_type;
263 result_type operator()(
264 typename _and_impl::expr_param e
265 , typename _and_impl::state_param s
266 , typename _and_impl::data_param d
267 ) const
268 {
269
270
271
272
273 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d);
274 return Gimpl8()(e,s,d);
275 }
276 };
277
278
279
280 template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8>
281 struct and_10
282 : and_9<
283 P0::value ,
284 P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8
285 >
286 {};
287 template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8>
288 struct and_10<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8>
289 : mpl::false_
290 {};
291 template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9, typename Expr, typename State, typename Data>
292 struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9>, Expr, State, Data>
293 : proto::transform_impl<Expr, State, Data>
294 {
295 typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8; typedef typename proto::when<proto::_, G9> ::template impl<Expr, State, Data> Gimpl9;
296 typedef typename Gimpl9::result_type result_type;
297 result_type operator()(
298 typename _and_impl::expr_param e
299 , typename _and_impl::state_param s
300 , typename _and_impl::data_param d
301 ) const
302 {
303
304
305
306
307 Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d); Gimpl8()(e,s,d);
308 return Gimpl9()(e,s,d);
309 }
310 };
311