]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 | }; |