Line data Source code
1 : // This file was GENERATED by command:
2 : // pump.py gtest-param-util-generated.h.pump
3 : // DO NOT EDIT BY HAND!!!
4 :
5 : // Copyright 2008 Google Inc.
6 : // All Rights Reserved.
7 : //
8 : // Redistribution and use in source and binary forms, with or without
9 : // modification, are permitted provided that the following conditions are
10 : // met:
11 : //
12 : // * Redistributions of source code must retain the above copyright
13 : // notice, this list of conditions and the following disclaimer.
14 : // * Redistributions in binary form must reproduce the above
15 : // copyright notice, this list of conditions and the following disclaimer
16 : // in the documentation and/or other materials provided with the
17 : // distribution.
18 : // * Neither the name of Google Inc. nor the names of its
19 : // contributors may be used to endorse or promote products derived from
20 : // this software without specific prior written permission.
21 : //
22 : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 : // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 : // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 : // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 : // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 : // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 : // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 : // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 : // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 : // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 : //
34 : // Author: vladl@google.com (Vlad Losev)
35 :
36 : // Type and function utilities for implementing parameterized tests.
37 : // This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
38 : //
39 : // Currently Google Test supports at most 50 arguments in Values,
40 : // and at most 10 arguments in Combine. Please contact
41 : // googletestframework@googlegroups.com if you need more.
42 : // Please note that the number of arguments to Combine is limited
43 : // by the maximum arity of the implementation of tr1::tuple which is
44 : // currently set at 10.
45 :
46 : #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
47 : #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
48 :
49 : // scripts/fuse_gtest.py depends on gtest's own header being #included
50 : // *unconditionally*. Therefore these #includes cannot be moved
51 : // inside #if GTEST_HAS_PARAM_TEST.
52 : #include "gtest/internal/gtest-param-util.h"
53 : #include "gtest/internal/gtest-port.h"
54 :
55 : #if GTEST_HAS_PARAM_TEST
56 :
57 : namespace testing {
58 :
59 : // Forward declarations of ValuesIn(), which is implemented in
60 : // include/gtest/gtest-param-test.h.
61 : template <typename ForwardIterator>
62 : internal::ParamGenerator<
63 : typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
64 : ValuesIn(ForwardIterator begin, ForwardIterator end);
65 :
66 : template <typename T, size_t N>
67 : internal::ParamGenerator<T> ValuesIn(const T (&array)[N]);
68 :
69 : template <class Container>
70 : internal::ParamGenerator<typename Container::value_type> ValuesIn(
71 : const Container& container);
72 :
73 : namespace internal {
74 :
75 : // Used in the Values() function to provide polymorphic capabilities.
76 : template <typename T1>
77 : class ValueArray1 {
78 : public:
79 12 : explicit ValueArray1(T1 v1) : v1_(v1) {}
80 :
81 : template <typename T>
82 12 : operator ParamGenerator<T>() const { return ValuesIn(&v1_, &v1_ + 1); }
83 :
84 : private:
85 : // No implementation - assignment is unsupported.
86 : void operator=(const ValueArray1& other);
87 :
88 : const T1 v1_;
89 : };
90 :
91 : template <typename T1, typename T2>
92 : class ValueArray2 {
93 : public:
94 27 : ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}
95 :
96 : template <typename T>
97 27 : operator ParamGenerator<T>() const {
98 27 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_)};
99 27 : return ValuesIn(array);
100 : }
101 :
102 : private:
103 : // No implementation - assignment is unsupported.
104 : void operator=(const ValueArray2& other);
105 :
106 : const T1 v1_;
107 : const T2 v2_;
108 : };
109 :
110 : template <typename T1, typename T2, typename T3>
111 : class ValueArray3 {
112 : public:
113 : ValueArray3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {}
114 :
115 : template <typename T>
116 : operator ParamGenerator<T>() const {
117 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
118 : static_cast<T>(v3_)};
119 : return ValuesIn(array);
120 : }
121 :
122 : private:
123 : // No implementation - assignment is unsupported.
124 : void operator=(const ValueArray3& other);
125 :
126 : const T1 v1_;
127 : const T2 v2_;
128 : const T3 v3_;
129 : };
130 :
131 : template <typename T1, typename T2, typename T3, typename T4>
132 : class ValueArray4 {
133 : public:
134 11 : ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3),
135 11 : v4_(v4) {}
136 :
137 : template <typename T>
138 11 : operator ParamGenerator<T>() const {
139 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
140 11 : static_cast<T>(v3_), static_cast<T>(v4_)};
141 11 : return ValuesIn(array);
142 : }
143 :
144 : private:
145 : // No implementation - assignment is unsupported.
146 : void operator=(const ValueArray4& other);
147 :
148 : const T1 v1_;
149 : const T2 v2_;
150 : const T3 v3_;
151 : const T4 v4_;
152 : };
153 :
154 : template <typename T1, typename T2, typename T3, typename T4, typename T5>
155 : class ValueArray5 {
156 : public:
157 : ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3),
158 : v4_(v4), v5_(v5) {}
159 :
160 : template <typename T>
161 : operator ParamGenerator<T>() const {
162 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
163 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_)};
164 : return ValuesIn(array);
165 : }
166 :
167 : private:
168 : // No implementation - assignment is unsupported.
169 : void operator=(const ValueArray5& other);
170 :
171 : const T1 v1_;
172 : const T2 v2_;
173 : const T3 v3_;
174 : const T4 v4_;
175 : const T5 v5_;
176 : };
177 :
178 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
179 : typename T6>
180 : class ValueArray6 {
181 : public:
182 : ValueArray6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) : v1_(v1), v2_(v2),
183 : v3_(v3), v4_(v4), v5_(v5), v6_(v6) {}
184 :
185 : template <typename T>
186 : operator ParamGenerator<T>() const {
187 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
188 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
189 : static_cast<T>(v6_)};
190 : return ValuesIn(array);
191 : }
192 :
193 : private:
194 : // No implementation - assignment is unsupported.
195 : void operator=(const ValueArray6& other);
196 :
197 : const T1 v1_;
198 : const T2 v2_;
199 : const T3 v3_;
200 : const T4 v4_;
201 : const T5 v5_;
202 : const T6 v6_;
203 : };
204 :
205 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
206 : typename T6, typename T7>
207 : class ValueArray7 {
208 : public:
209 : ValueArray7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) : v1_(v1),
210 : v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7) {}
211 :
212 : template <typename T>
213 : operator ParamGenerator<T>() const {
214 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
215 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
216 : static_cast<T>(v6_), static_cast<T>(v7_)};
217 : return ValuesIn(array);
218 : }
219 :
220 : private:
221 : // No implementation - assignment is unsupported.
222 : void operator=(const ValueArray7& other);
223 :
224 : const T1 v1_;
225 : const T2 v2_;
226 : const T3 v3_;
227 : const T4 v4_;
228 : const T5 v5_;
229 : const T6 v6_;
230 : const T7 v7_;
231 : };
232 :
233 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
234 : typename T6, typename T7, typename T8>
235 : class ValueArray8 {
236 : public:
237 : ValueArray8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
238 : T8 v8) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
239 : v8_(v8) {}
240 :
241 : template <typename T>
242 : operator ParamGenerator<T>() const {
243 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
244 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
245 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_)};
246 : return ValuesIn(array);
247 : }
248 :
249 : private:
250 : // No implementation - assignment is unsupported.
251 : void operator=(const ValueArray8& other);
252 :
253 : const T1 v1_;
254 : const T2 v2_;
255 : const T3 v3_;
256 : const T4 v4_;
257 : const T5 v5_;
258 : const T6 v6_;
259 : const T7 v7_;
260 : const T8 v8_;
261 : };
262 :
263 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
264 : typename T6, typename T7, typename T8, typename T9>
265 : class ValueArray9 {
266 : public:
267 : ValueArray9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
268 : T9 v9) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
269 : v8_(v8), v9_(v9) {}
270 :
271 : template <typename T>
272 : operator ParamGenerator<T>() const {
273 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
274 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
275 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
276 : static_cast<T>(v9_)};
277 : return ValuesIn(array);
278 : }
279 :
280 : private:
281 : // No implementation - assignment is unsupported.
282 : void operator=(const ValueArray9& other);
283 :
284 : const T1 v1_;
285 : const T2 v2_;
286 : const T3 v3_;
287 : const T4 v4_;
288 : const T5 v5_;
289 : const T6 v6_;
290 : const T7 v7_;
291 : const T8 v8_;
292 : const T9 v9_;
293 : };
294 :
295 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
296 : typename T6, typename T7, typename T8, typename T9, typename T10>
297 : class ValueArray10 {
298 : public:
299 : ValueArray10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
300 : T10 v10) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
301 : v8_(v8), v9_(v9), v10_(v10) {}
302 :
303 : template <typename T>
304 : operator ParamGenerator<T>() const {
305 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
306 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
307 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
308 : static_cast<T>(v9_), static_cast<T>(v10_)};
309 : return ValuesIn(array);
310 : }
311 :
312 : private:
313 : // No implementation - assignment is unsupported.
314 : void operator=(const ValueArray10& other);
315 :
316 : const T1 v1_;
317 : const T2 v2_;
318 : const T3 v3_;
319 : const T4 v4_;
320 : const T5 v5_;
321 : const T6 v6_;
322 : const T7 v7_;
323 : const T8 v8_;
324 : const T9 v9_;
325 : const T10 v10_;
326 : };
327 :
328 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
329 : typename T6, typename T7, typename T8, typename T9, typename T10,
330 : typename T11>
331 : class ValueArray11 {
332 : public:
333 : ValueArray11(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
334 : T10 v10, T11 v11) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
335 : v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11) {}
336 :
337 : template <typename T>
338 : operator ParamGenerator<T>() const {
339 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
340 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
341 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
342 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_)};
343 : return ValuesIn(array);
344 : }
345 :
346 : private:
347 : // No implementation - assignment is unsupported.
348 : void operator=(const ValueArray11& other);
349 :
350 : const T1 v1_;
351 : const T2 v2_;
352 : const T3 v3_;
353 : const T4 v4_;
354 : const T5 v5_;
355 : const T6 v6_;
356 : const T7 v7_;
357 : const T8 v8_;
358 : const T9 v9_;
359 : const T10 v10_;
360 : const T11 v11_;
361 : };
362 :
363 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
364 : typename T6, typename T7, typename T8, typename T9, typename T10,
365 : typename T11, typename T12>
366 : class ValueArray12 {
367 : public:
368 : ValueArray12(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
369 : T10 v10, T11 v11, T12 v12) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
370 : v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12) {}
371 :
372 : template <typename T>
373 : operator ParamGenerator<T>() const {
374 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
375 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
376 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
377 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
378 : static_cast<T>(v12_)};
379 : return ValuesIn(array);
380 : }
381 :
382 : private:
383 : // No implementation - assignment is unsupported.
384 : void operator=(const ValueArray12& other);
385 :
386 : const T1 v1_;
387 : const T2 v2_;
388 : const T3 v3_;
389 : const T4 v4_;
390 : const T5 v5_;
391 : const T6 v6_;
392 : const T7 v7_;
393 : const T8 v8_;
394 : const T9 v9_;
395 : const T10 v10_;
396 : const T11 v11_;
397 : const T12 v12_;
398 : };
399 :
400 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
401 : typename T6, typename T7, typename T8, typename T9, typename T10,
402 : typename T11, typename T12, typename T13>
403 : class ValueArray13 {
404 : public:
405 : ValueArray13(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
406 : T10 v10, T11 v11, T12 v12, T13 v13) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
407 : v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
408 : v12_(v12), v13_(v13) {}
409 :
410 : template <typename T>
411 : operator ParamGenerator<T>() const {
412 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
413 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
414 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
415 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
416 : static_cast<T>(v12_), static_cast<T>(v13_)};
417 : return ValuesIn(array);
418 : }
419 :
420 : private:
421 : // No implementation - assignment is unsupported.
422 : void operator=(const ValueArray13& other);
423 :
424 : const T1 v1_;
425 : const T2 v2_;
426 : const T3 v3_;
427 : const T4 v4_;
428 : const T5 v5_;
429 : const T6 v6_;
430 : const T7 v7_;
431 : const T8 v8_;
432 : const T9 v9_;
433 : const T10 v10_;
434 : const T11 v11_;
435 : const T12 v12_;
436 : const T13 v13_;
437 : };
438 :
439 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
440 : typename T6, typename T7, typename T8, typename T9, typename T10,
441 : typename T11, typename T12, typename T13, typename T14>
442 : class ValueArray14 {
443 : public:
444 : ValueArray14(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
445 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) : v1_(v1), v2_(v2), v3_(v3),
446 : v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
447 : v11_(v11), v12_(v12), v13_(v13), v14_(v14) {}
448 :
449 : template <typename T>
450 : operator ParamGenerator<T>() const {
451 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
452 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
453 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
454 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
455 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_)};
456 : return ValuesIn(array);
457 : }
458 :
459 : private:
460 : // No implementation - assignment is unsupported.
461 : void operator=(const ValueArray14& other);
462 :
463 : const T1 v1_;
464 : const T2 v2_;
465 : const T3 v3_;
466 : const T4 v4_;
467 : const T5 v5_;
468 : const T6 v6_;
469 : const T7 v7_;
470 : const T8 v8_;
471 : const T9 v9_;
472 : const T10 v10_;
473 : const T11 v11_;
474 : const T12 v12_;
475 : const T13 v13_;
476 : const T14 v14_;
477 : };
478 :
479 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
480 : typename T6, typename T7, typename T8, typename T9, typename T10,
481 : typename T11, typename T12, typename T13, typename T14, typename T15>
482 : class ValueArray15 {
483 : public:
484 : ValueArray15(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
485 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) : v1_(v1), v2_(v2),
486 : v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
487 : v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15) {}
488 :
489 : template <typename T>
490 : operator ParamGenerator<T>() const {
491 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
492 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
493 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
494 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
495 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
496 : static_cast<T>(v15_)};
497 : return ValuesIn(array);
498 : }
499 :
500 : private:
501 : // No implementation - assignment is unsupported.
502 : void operator=(const ValueArray15& other);
503 :
504 : const T1 v1_;
505 : const T2 v2_;
506 : const T3 v3_;
507 : const T4 v4_;
508 : const T5 v5_;
509 : const T6 v6_;
510 : const T7 v7_;
511 : const T8 v8_;
512 : const T9 v9_;
513 : const T10 v10_;
514 : const T11 v11_;
515 : const T12 v12_;
516 : const T13 v13_;
517 : const T14 v14_;
518 : const T15 v15_;
519 : };
520 :
521 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
522 : typename T6, typename T7, typename T8, typename T9, typename T10,
523 : typename T11, typename T12, typename T13, typename T14, typename T15,
524 : typename T16>
525 : class ValueArray16 {
526 : public:
527 : ValueArray16(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
528 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) : v1_(v1),
529 : v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
530 : v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
531 : v16_(v16) {}
532 :
533 : template <typename T>
534 : operator ParamGenerator<T>() const {
535 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
536 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
537 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
538 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
539 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
540 : static_cast<T>(v15_), static_cast<T>(v16_)};
541 : return ValuesIn(array);
542 : }
543 :
544 : private:
545 : // No implementation - assignment is unsupported.
546 : void operator=(const ValueArray16& other);
547 :
548 : const T1 v1_;
549 : const T2 v2_;
550 : const T3 v3_;
551 : const T4 v4_;
552 : const T5 v5_;
553 : const T6 v6_;
554 : const T7 v7_;
555 : const T8 v8_;
556 : const T9 v9_;
557 : const T10 v10_;
558 : const T11 v11_;
559 : const T12 v12_;
560 : const T13 v13_;
561 : const T14 v14_;
562 : const T15 v15_;
563 : const T16 v16_;
564 : };
565 :
566 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
567 : typename T6, typename T7, typename T8, typename T9, typename T10,
568 : typename T11, typename T12, typename T13, typename T14, typename T15,
569 : typename T16, typename T17>
570 : class ValueArray17 {
571 : public:
572 : ValueArray17(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
573 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
574 : T17 v17) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
575 : v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
576 : v15_(v15), v16_(v16), v17_(v17) {}
577 :
578 : template <typename T>
579 : operator ParamGenerator<T>() const {
580 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
581 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
582 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
583 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
584 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
585 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_)};
586 : return ValuesIn(array);
587 : }
588 :
589 : private:
590 : // No implementation - assignment is unsupported.
591 : void operator=(const ValueArray17& other);
592 :
593 : const T1 v1_;
594 : const T2 v2_;
595 : const T3 v3_;
596 : const T4 v4_;
597 : const T5 v5_;
598 : const T6 v6_;
599 : const T7 v7_;
600 : const T8 v8_;
601 : const T9 v9_;
602 : const T10 v10_;
603 : const T11 v11_;
604 : const T12 v12_;
605 : const T13 v13_;
606 : const T14 v14_;
607 : const T15 v15_;
608 : const T16 v16_;
609 : const T17 v17_;
610 : };
611 :
612 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
613 : typename T6, typename T7, typename T8, typename T9, typename T10,
614 : typename T11, typename T12, typename T13, typename T14, typename T15,
615 : typename T16, typename T17, typename T18>
616 : class ValueArray18 {
617 : public:
618 : ValueArray18(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
619 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
620 : T18 v18) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
621 : v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
622 : v15_(v15), v16_(v16), v17_(v17), v18_(v18) {}
623 :
624 : template <typename T>
625 : operator ParamGenerator<T>() const {
626 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
627 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
628 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
629 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
630 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
631 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
632 : static_cast<T>(v18_)};
633 : return ValuesIn(array);
634 : }
635 :
636 : private:
637 : // No implementation - assignment is unsupported.
638 : void operator=(const ValueArray18& other);
639 :
640 : const T1 v1_;
641 : const T2 v2_;
642 : const T3 v3_;
643 : const T4 v4_;
644 : const T5 v5_;
645 : const T6 v6_;
646 : const T7 v7_;
647 : const T8 v8_;
648 : const T9 v9_;
649 : const T10 v10_;
650 : const T11 v11_;
651 : const T12 v12_;
652 : const T13 v13_;
653 : const T14 v14_;
654 : const T15 v15_;
655 : const T16 v16_;
656 : const T17 v17_;
657 : const T18 v18_;
658 : };
659 :
660 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
661 : typename T6, typename T7, typename T8, typename T9, typename T10,
662 : typename T11, typename T12, typename T13, typename T14, typename T15,
663 : typename T16, typename T17, typename T18, typename T19>
664 : class ValueArray19 {
665 : public:
666 : ValueArray19(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
667 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
668 : T18 v18, T19 v19) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
669 : v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
670 : v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19) {}
671 :
672 : template <typename T>
673 : operator ParamGenerator<T>() const {
674 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
675 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
676 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
677 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
678 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
679 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
680 : static_cast<T>(v18_), static_cast<T>(v19_)};
681 : return ValuesIn(array);
682 : }
683 :
684 : private:
685 : // No implementation - assignment is unsupported.
686 : void operator=(const ValueArray19& other);
687 :
688 : const T1 v1_;
689 : const T2 v2_;
690 : const T3 v3_;
691 : const T4 v4_;
692 : const T5 v5_;
693 : const T6 v6_;
694 : const T7 v7_;
695 : const T8 v8_;
696 : const T9 v9_;
697 : const T10 v10_;
698 : const T11 v11_;
699 : const T12 v12_;
700 : const T13 v13_;
701 : const T14 v14_;
702 : const T15 v15_;
703 : const T16 v16_;
704 : const T17 v17_;
705 : const T18 v18_;
706 : const T19 v19_;
707 : };
708 :
709 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
710 : typename T6, typename T7, typename T8, typename T9, typename T10,
711 : typename T11, typename T12, typename T13, typename T14, typename T15,
712 : typename T16, typename T17, typename T18, typename T19, typename T20>
713 : class ValueArray20 {
714 : public:
715 : ValueArray20(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
716 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
717 : T18 v18, T19 v19, T20 v20) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
718 : v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
719 : v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
720 : v19_(v19), v20_(v20) {}
721 :
722 : template <typename T>
723 : operator ParamGenerator<T>() const {
724 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
725 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
726 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
727 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
728 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
729 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
730 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_)};
731 : return ValuesIn(array);
732 : }
733 :
734 : private:
735 : // No implementation - assignment is unsupported.
736 : void operator=(const ValueArray20& other);
737 :
738 : const T1 v1_;
739 : const T2 v2_;
740 : const T3 v3_;
741 : const T4 v4_;
742 : const T5 v5_;
743 : const T6 v6_;
744 : const T7 v7_;
745 : const T8 v8_;
746 : const T9 v9_;
747 : const T10 v10_;
748 : const T11 v11_;
749 : const T12 v12_;
750 : const T13 v13_;
751 : const T14 v14_;
752 : const T15 v15_;
753 : const T16 v16_;
754 : const T17 v17_;
755 : const T18 v18_;
756 : const T19 v19_;
757 : const T20 v20_;
758 : };
759 :
760 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
761 : typename T6, typename T7, typename T8, typename T9, typename T10,
762 : typename T11, typename T12, typename T13, typename T14, typename T15,
763 : typename T16, typename T17, typename T18, typename T19, typename T20,
764 : typename T21>
765 : class ValueArray21 {
766 : public:
767 : ValueArray21(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
768 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
769 : T18 v18, T19 v19, T20 v20, T21 v21) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
770 : v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
771 : v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
772 : v18_(v18), v19_(v19), v20_(v20), v21_(v21) {}
773 :
774 : template <typename T>
775 : operator ParamGenerator<T>() const {
776 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
777 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
778 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
779 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
780 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
781 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
782 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
783 : static_cast<T>(v21_)};
784 : return ValuesIn(array);
785 : }
786 :
787 : private:
788 : // No implementation - assignment is unsupported.
789 : void operator=(const ValueArray21& other);
790 :
791 : const T1 v1_;
792 : const T2 v2_;
793 : const T3 v3_;
794 : const T4 v4_;
795 : const T5 v5_;
796 : const T6 v6_;
797 : const T7 v7_;
798 : const T8 v8_;
799 : const T9 v9_;
800 : const T10 v10_;
801 : const T11 v11_;
802 : const T12 v12_;
803 : const T13 v13_;
804 : const T14 v14_;
805 : const T15 v15_;
806 : const T16 v16_;
807 : const T17 v17_;
808 : const T18 v18_;
809 : const T19 v19_;
810 : const T20 v20_;
811 : const T21 v21_;
812 : };
813 :
814 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
815 : typename T6, typename T7, typename T8, typename T9, typename T10,
816 : typename T11, typename T12, typename T13, typename T14, typename T15,
817 : typename T16, typename T17, typename T18, typename T19, typename T20,
818 : typename T21, typename T22>
819 : class ValueArray22 {
820 : public:
821 : ValueArray22(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
822 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
823 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22) : v1_(v1), v2_(v2), v3_(v3),
824 : v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
825 : v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
826 : v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22) {}
827 :
828 : template <typename T>
829 : operator ParamGenerator<T>() const {
830 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
831 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
832 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
833 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
834 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
835 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
836 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
837 : static_cast<T>(v21_), static_cast<T>(v22_)};
838 : return ValuesIn(array);
839 : }
840 :
841 : private:
842 : // No implementation - assignment is unsupported.
843 : void operator=(const ValueArray22& other);
844 :
845 : const T1 v1_;
846 : const T2 v2_;
847 : const T3 v3_;
848 : const T4 v4_;
849 : const T5 v5_;
850 : const T6 v6_;
851 : const T7 v7_;
852 : const T8 v8_;
853 : const T9 v9_;
854 : const T10 v10_;
855 : const T11 v11_;
856 : const T12 v12_;
857 : const T13 v13_;
858 : const T14 v14_;
859 : const T15 v15_;
860 : const T16 v16_;
861 : const T17 v17_;
862 : const T18 v18_;
863 : const T19 v19_;
864 : const T20 v20_;
865 : const T21 v21_;
866 : const T22 v22_;
867 : };
868 :
869 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
870 : typename T6, typename T7, typename T8, typename T9, typename T10,
871 : typename T11, typename T12, typename T13, typename T14, typename T15,
872 : typename T16, typename T17, typename T18, typename T19, typename T20,
873 : typename T21, typename T22, typename T23>
874 : class ValueArray23 {
875 : public:
876 : ValueArray23(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
877 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
878 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23) : v1_(v1), v2_(v2),
879 : v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
880 : v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
881 : v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
882 : v23_(v23) {}
883 :
884 : template <typename T>
885 : operator ParamGenerator<T>() const {
886 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
887 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
888 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
889 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
890 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
891 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
892 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
893 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_)};
894 : return ValuesIn(array);
895 : }
896 :
897 : private:
898 : // No implementation - assignment is unsupported.
899 : void operator=(const ValueArray23& other);
900 :
901 : const T1 v1_;
902 : const T2 v2_;
903 : const T3 v3_;
904 : const T4 v4_;
905 : const T5 v5_;
906 : const T6 v6_;
907 : const T7 v7_;
908 : const T8 v8_;
909 : const T9 v9_;
910 : const T10 v10_;
911 : const T11 v11_;
912 : const T12 v12_;
913 : const T13 v13_;
914 : const T14 v14_;
915 : const T15 v15_;
916 : const T16 v16_;
917 : const T17 v17_;
918 : const T18 v18_;
919 : const T19 v19_;
920 : const T20 v20_;
921 : const T21 v21_;
922 : const T22 v22_;
923 : const T23 v23_;
924 : };
925 :
926 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
927 : typename T6, typename T7, typename T8, typename T9, typename T10,
928 : typename T11, typename T12, typename T13, typename T14, typename T15,
929 : typename T16, typename T17, typename T18, typename T19, typename T20,
930 : typename T21, typename T22, typename T23, typename T24>
931 : class ValueArray24 {
932 : public:
933 : ValueArray24(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
934 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
935 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24) : v1_(v1),
936 : v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
937 : v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
938 : v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
939 : v22_(v22), v23_(v23), v24_(v24) {}
940 :
941 : template <typename T>
942 : operator ParamGenerator<T>() const {
943 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
944 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
945 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
946 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
947 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
948 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
949 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
950 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
951 : static_cast<T>(v24_)};
952 : return ValuesIn(array);
953 : }
954 :
955 : private:
956 : // No implementation - assignment is unsupported.
957 : void operator=(const ValueArray24& other);
958 :
959 : const T1 v1_;
960 : const T2 v2_;
961 : const T3 v3_;
962 : const T4 v4_;
963 : const T5 v5_;
964 : const T6 v6_;
965 : const T7 v7_;
966 : const T8 v8_;
967 : const T9 v9_;
968 : const T10 v10_;
969 : const T11 v11_;
970 : const T12 v12_;
971 : const T13 v13_;
972 : const T14 v14_;
973 : const T15 v15_;
974 : const T16 v16_;
975 : const T17 v17_;
976 : const T18 v18_;
977 : const T19 v19_;
978 : const T20 v20_;
979 : const T21 v21_;
980 : const T22 v22_;
981 : const T23 v23_;
982 : const T24 v24_;
983 : };
984 :
985 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
986 : typename T6, typename T7, typename T8, typename T9, typename T10,
987 : typename T11, typename T12, typename T13, typename T14, typename T15,
988 : typename T16, typename T17, typename T18, typename T19, typename T20,
989 : typename T21, typename T22, typename T23, typename T24, typename T25>
990 : class ValueArray25 {
991 : public:
992 : ValueArray25(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
993 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
994 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
995 : T25 v25) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
996 : v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
997 : v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
998 : v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25) {}
999 :
1000 : template <typename T>
1001 : operator ParamGenerator<T>() const {
1002 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
1003 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
1004 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
1005 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
1006 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
1007 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
1008 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
1009 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
1010 : static_cast<T>(v24_), static_cast<T>(v25_)};
1011 : return ValuesIn(array);
1012 : }
1013 :
1014 : private:
1015 : // No implementation - assignment is unsupported.
1016 : void operator=(const ValueArray25& other);
1017 :
1018 : const T1 v1_;
1019 : const T2 v2_;
1020 : const T3 v3_;
1021 : const T4 v4_;
1022 : const T5 v5_;
1023 : const T6 v6_;
1024 : const T7 v7_;
1025 : const T8 v8_;
1026 : const T9 v9_;
1027 : const T10 v10_;
1028 : const T11 v11_;
1029 : const T12 v12_;
1030 : const T13 v13_;
1031 : const T14 v14_;
1032 : const T15 v15_;
1033 : const T16 v16_;
1034 : const T17 v17_;
1035 : const T18 v18_;
1036 : const T19 v19_;
1037 : const T20 v20_;
1038 : const T21 v21_;
1039 : const T22 v22_;
1040 : const T23 v23_;
1041 : const T24 v24_;
1042 : const T25 v25_;
1043 : };
1044 :
1045 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
1046 : typename T6, typename T7, typename T8, typename T9, typename T10,
1047 : typename T11, typename T12, typename T13, typename T14, typename T15,
1048 : typename T16, typename T17, typename T18, typename T19, typename T20,
1049 : typename T21, typename T22, typename T23, typename T24, typename T25,
1050 : typename T26>
1051 : class ValueArray26 {
1052 : public:
1053 : ValueArray26(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
1054 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
1055 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
1056 : T26 v26) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
1057 : v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
1058 : v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
1059 : v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26) {}
1060 :
1061 : template <typename T>
1062 : operator ParamGenerator<T>() const {
1063 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
1064 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
1065 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
1066 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
1067 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
1068 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
1069 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
1070 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
1071 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_)};
1072 : return ValuesIn(array);
1073 : }
1074 :
1075 : private:
1076 : // No implementation - assignment is unsupported.
1077 : void operator=(const ValueArray26& other);
1078 :
1079 : const T1 v1_;
1080 : const T2 v2_;
1081 : const T3 v3_;
1082 : const T4 v4_;
1083 : const T5 v5_;
1084 : const T6 v6_;
1085 : const T7 v7_;
1086 : const T8 v8_;
1087 : const T9 v9_;
1088 : const T10 v10_;
1089 : const T11 v11_;
1090 : const T12 v12_;
1091 : const T13 v13_;
1092 : const T14 v14_;
1093 : const T15 v15_;
1094 : const T16 v16_;
1095 : const T17 v17_;
1096 : const T18 v18_;
1097 : const T19 v19_;
1098 : const T20 v20_;
1099 : const T21 v21_;
1100 : const T22 v22_;
1101 : const T23 v23_;
1102 : const T24 v24_;
1103 : const T25 v25_;
1104 : const T26 v26_;
1105 : };
1106 :
1107 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
1108 : typename T6, typename T7, typename T8, typename T9, typename T10,
1109 : typename T11, typename T12, typename T13, typename T14, typename T15,
1110 : typename T16, typename T17, typename T18, typename T19, typename T20,
1111 : typename T21, typename T22, typename T23, typename T24, typename T25,
1112 : typename T26, typename T27>
1113 : class ValueArray27 {
1114 : public:
1115 : ValueArray27(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
1116 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
1117 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
1118 : T26 v26, T27 v27) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
1119 : v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
1120 : v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
1121 : v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
1122 : v26_(v26), v27_(v27) {}
1123 :
1124 : template <typename T>
1125 : operator ParamGenerator<T>() const {
1126 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
1127 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
1128 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
1129 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
1130 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
1131 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
1132 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
1133 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
1134 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
1135 : static_cast<T>(v27_)};
1136 : return ValuesIn(array);
1137 : }
1138 :
1139 : private:
1140 : // No implementation - assignment is unsupported.
1141 : void operator=(const ValueArray27& other);
1142 :
1143 : const T1 v1_;
1144 : const T2 v2_;
1145 : const T3 v3_;
1146 : const T4 v4_;
1147 : const T5 v5_;
1148 : const T6 v6_;
1149 : const T7 v7_;
1150 : const T8 v8_;
1151 : const T9 v9_;
1152 : const T10 v10_;
1153 : const T11 v11_;
1154 : const T12 v12_;
1155 : const T13 v13_;
1156 : const T14 v14_;
1157 : const T15 v15_;
1158 : const T16 v16_;
1159 : const T17 v17_;
1160 : const T18 v18_;
1161 : const T19 v19_;
1162 : const T20 v20_;
1163 : const T21 v21_;
1164 : const T22 v22_;
1165 : const T23 v23_;
1166 : const T24 v24_;
1167 : const T25 v25_;
1168 : const T26 v26_;
1169 : const T27 v27_;
1170 : };
1171 :
1172 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
1173 : typename T6, typename T7, typename T8, typename T9, typename T10,
1174 : typename T11, typename T12, typename T13, typename T14, typename T15,
1175 : typename T16, typename T17, typename T18, typename T19, typename T20,
1176 : typename T21, typename T22, typename T23, typename T24, typename T25,
1177 : typename T26, typename T27, typename T28>
1178 : class ValueArray28 {
1179 : public:
1180 : ValueArray28(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
1181 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
1182 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
1183 : T26 v26, T27 v27, T28 v28) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
1184 : v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
1185 : v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
1186 : v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
1187 : v25_(v25), v26_(v26), v27_(v27), v28_(v28) {}
1188 :
1189 : template <typename T>
1190 : operator ParamGenerator<T>() const {
1191 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
1192 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
1193 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
1194 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
1195 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
1196 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
1197 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
1198 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
1199 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
1200 : static_cast<T>(v27_), static_cast<T>(v28_)};
1201 : return ValuesIn(array);
1202 : }
1203 :
1204 : private:
1205 : // No implementation - assignment is unsupported.
1206 : void operator=(const ValueArray28& other);
1207 :
1208 : const T1 v1_;
1209 : const T2 v2_;
1210 : const T3 v3_;
1211 : const T4 v4_;
1212 : const T5 v5_;
1213 : const T6 v6_;
1214 : const T7 v7_;
1215 : const T8 v8_;
1216 : const T9 v9_;
1217 : const T10 v10_;
1218 : const T11 v11_;
1219 : const T12 v12_;
1220 : const T13 v13_;
1221 : const T14 v14_;
1222 : const T15 v15_;
1223 : const T16 v16_;
1224 : const T17 v17_;
1225 : const T18 v18_;
1226 : const T19 v19_;
1227 : const T20 v20_;
1228 : const T21 v21_;
1229 : const T22 v22_;
1230 : const T23 v23_;
1231 : const T24 v24_;
1232 : const T25 v25_;
1233 : const T26 v26_;
1234 : const T27 v27_;
1235 : const T28 v28_;
1236 : };
1237 :
1238 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
1239 : typename T6, typename T7, typename T8, typename T9, typename T10,
1240 : typename T11, typename T12, typename T13, typename T14, typename T15,
1241 : typename T16, typename T17, typename T18, typename T19, typename T20,
1242 : typename T21, typename T22, typename T23, typename T24, typename T25,
1243 : typename T26, typename T27, typename T28, typename T29>
1244 : class ValueArray29 {
1245 : public:
1246 : ValueArray29(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
1247 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
1248 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
1249 : T26 v26, T27 v27, T28 v28, T29 v29) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
1250 : v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
1251 : v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
1252 : v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
1253 : v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29) {}
1254 :
1255 : template <typename T>
1256 : operator ParamGenerator<T>() const {
1257 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
1258 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
1259 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
1260 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
1261 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
1262 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
1263 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
1264 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
1265 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
1266 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_)};
1267 : return ValuesIn(array);
1268 : }
1269 :
1270 : private:
1271 : // No implementation - assignment is unsupported.
1272 : void operator=(const ValueArray29& other);
1273 :
1274 : const T1 v1_;
1275 : const T2 v2_;
1276 : const T3 v3_;
1277 : const T4 v4_;
1278 : const T5 v5_;
1279 : const T6 v6_;
1280 : const T7 v7_;
1281 : const T8 v8_;
1282 : const T9 v9_;
1283 : const T10 v10_;
1284 : const T11 v11_;
1285 : const T12 v12_;
1286 : const T13 v13_;
1287 : const T14 v14_;
1288 : const T15 v15_;
1289 : const T16 v16_;
1290 : const T17 v17_;
1291 : const T18 v18_;
1292 : const T19 v19_;
1293 : const T20 v20_;
1294 : const T21 v21_;
1295 : const T22 v22_;
1296 : const T23 v23_;
1297 : const T24 v24_;
1298 : const T25 v25_;
1299 : const T26 v26_;
1300 : const T27 v27_;
1301 : const T28 v28_;
1302 : const T29 v29_;
1303 : };
1304 :
1305 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
1306 : typename T6, typename T7, typename T8, typename T9, typename T10,
1307 : typename T11, typename T12, typename T13, typename T14, typename T15,
1308 : typename T16, typename T17, typename T18, typename T19, typename T20,
1309 : typename T21, typename T22, typename T23, typename T24, typename T25,
1310 : typename T26, typename T27, typename T28, typename T29, typename T30>
1311 : class ValueArray30 {
1312 : public:
1313 : ValueArray30(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
1314 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
1315 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
1316 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) : v1_(v1), v2_(v2), v3_(v3),
1317 : v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
1318 : v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
1319 : v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
1320 : v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
1321 : v29_(v29), v30_(v30) {}
1322 :
1323 : template <typename T>
1324 : operator ParamGenerator<T>() const {
1325 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
1326 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
1327 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
1328 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
1329 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
1330 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
1331 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
1332 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
1333 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
1334 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
1335 : static_cast<T>(v30_)};
1336 : return ValuesIn(array);
1337 : }
1338 :
1339 : private:
1340 : // No implementation - assignment is unsupported.
1341 : void operator=(const ValueArray30& other);
1342 :
1343 : const T1 v1_;
1344 : const T2 v2_;
1345 : const T3 v3_;
1346 : const T4 v4_;
1347 : const T5 v5_;
1348 : const T6 v6_;
1349 : const T7 v7_;
1350 : const T8 v8_;
1351 : const T9 v9_;
1352 : const T10 v10_;
1353 : const T11 v11_;
1354 : const T12 v12_;
1355 : const T13 v13_;
1356 : const T14 v14_;
1357 : const T15 v15_;
1358 : const T16 v16_;
1359 : const T17 v17_;
1360 : const T18 v18_;
1361 : const T19 v19_;
1362 : const T20 v20_;
1363 : const T21 v21_;
1364 : const T22 v22_;
1365 : const T23 v23_;
1366 : const T24 v24_;
1367 : const T25 v25_;
1368 : const T26 v26_;
1369 : const T27 v27_;
1370 : const T28 v28_;
1371 : const T29 v29_;
1372 : const T30 v30_;
1373 : };
1374 :
1375 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
1376 : typename T6, typename T7, typename T8, typename T9, typename T10,
1377 : typename T11, typename T12, typename T13, typename T14, typename T15,
1378 : typename T16, typename T17, typename T18, typename T19, typename T20,
1379 : typename T21, typename T22, typename T23, typename T24, typename T25,
1380 : typename T26, typename T27, typename T28, typename T29, typename T30,
1381 : typename T31>
1382 : class ValueArray31 {
1383 : public:
1384 : ValueArray31(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
1385 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
1386 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
1387 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) : v1_(v1), v2_(v2),
1388 : v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
1389 : v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
1390 : v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
1391 : v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
1392 : v29_(v29), v30_(v30), v31_(v31) {}
1393 :
1394 : template <typename T>
1395 : operator ParamGenerator<T>() const {
1396 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
1397 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
1398 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
1399 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
1400 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
1401 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
1402 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
1403 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
1404 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
1405 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
1406 : static_cast<T>(v30_), static_cast<T>(v31_)};
1407 : return ValuesIn(array);
1408 : }
1409 :
1410 : private:
1411 : // No implementation - assignment is unsupported.
1412 : void operator=(const ValueArray31& other);
1413 :
1414 : const T1 v1_;
1415 : const T2 v2_;
1416 : const T3 v3_;
1417 : const T4 v4_;
1418 : const T5 v5_;
1419 : const T6 v6_;
1420 : const T7 v7_;
1421 : const T8 v8_;
1422 : const T9 v9_;
1423 : const T10 v10_;
1424 : const T11 v11_;
1425 : const T12 v12_;
1426 : const T13 v13_;
1427 : const T14 v14_;
1428 : const T15 v15_;
1429 : const T16 v16_;
1430 : const T17 v17_;
1431 : const T18 v18_;
1432 : const T19 v19_;
1433 : const T20 v20_;
1434 : const T21 v21_;
1435 : const T22 v22_;
1436 : const T23 v23_;
1437 : const T24 v24_;
1438 : const T25 v25_;
1439 : const T26 v26_;
1440 : const T27 v27_;
1441 : const T28 v28_;
1442 : const T29 v29_;
1443 : const T30 v30_;
1444 : const T31 v31_;
1445 : };
1446 :
1447 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
1448 : typename T6, typename T7, typename T8, typename T9, typename T10,
1449 : typename T11, typename T12, typename T13, typename T14, typename T15,
1450 : typename T16, typename T17, typename T18, typename T19, typename T20,
1451 : typename T21, typename T22, typename T23, typename T24, typename T25,
1452 : typename T26, typename T27, typename T28, typename T29, typename T30,
1453 : typename T31, typename T32>
1454 : class ValueArray32 {
1455 : public:
1456 : ValueArray32(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
1457 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
1458 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
1459 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32) : v1_(v1),
1460 : v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
1461 : v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
1462 : v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
1463 : v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
1464 : v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32) {}
1465 :
1466 : template <typename T>
1467 : operator ParamGenerator<T>() const {
1468 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
1469 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
1470 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
1471 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
1472 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
1473 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
1474 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
1475 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
1476 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
1477 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
1478 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_)};
1479 : return ValuesIn(array);
1480 : }
1481 :
1482 : private:
1483 : // No implementation - assignment is unsupported.
1484 : void operator=(const ValueArray32& other);
1485 :
1486 : const T1 v1_;
1487 : const T2 v2_;
1488 : const T3 v3_;
1489 : const T4 v4_;
1490 : const T5 v5_;
1491 : const T6 v6_;
1492 : const T7 v7_;
1493 : const T8 v8_;
1494 : const T9 v9_;
1495 : const T10 v10_;
1496 : const T11 v11_;
1497 : const T12 v12_;
1498 : const T13 v13_;
1499 : const T14 v14_;
1500 : const T15 v15_;
1501 : const T16 v16_;
1502 : const T17 v17_;
1503 : const T18 v18_;
1504 : const T19 v19_;
1505 : const T20 v20_;
1506 : const T21 v21_;
1507 : const T22 v22_;
1508 : const T23 v23_;
1509 : const T24 v24_;
1510 : const T25 v25_;
1511 : const T26 v26_;
1512 : const T27 v27_;
1513 : const T28 v28_;
1514 : const T29 v29_;
1515 : const T30 v30_;
1516 : const T31 v31_;
1517 : const T32 v32_;
1518 : };
1519 :
1520 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
1521 : typename T6, typename T7, typename T8, typename T9, typename T10,
1522 : typename T11, typename T12, typename T13, typename T14, typename T15,
1523 : typename T16, typename T17, typename T18, typename T19, typename T20,
1524 : typename T21, typename T22, typename T23, typename T24, typename T25,
1525 : typename T26, typename T27, typename T28, typename T29, typename T30,
1526 : typename T31, typename T32, typename T33>
1527 : class ValueArray33 {
1528 : public:
1529 : ValueArray33(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
1530 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
1531 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
1532 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32,
1533 : T33 v33) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
1534 : v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
1535 : v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
1536 : v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
1537 : v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
1538 : v33_(v33) {}
1539 :
1540 : template <typename T>
1541 : operator ParamGenerator<T>() const {
1542 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
1543 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
1544 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
1545 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
1546 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
1547 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
1548 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
1549 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
1550 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
1551 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
1552 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
1553 : static_cast<T>(v33_)};
1554 : return ValuesIn(array);
1555 : }
1556 :
1557 : private:
1558 : // No implementation - assignment is unsupported.
1559 : void operator=(const ValueArray33& other);
1560 :
1561 : const T1 v1_;
1562 : const T2 v2_;
1563 : const T3 v3_;
1564 : const T4 v4_;
1565 : const T5 v5_;
1566 : const T6 v6_;
1567 : const T7 v7_;
1568 : const T8 v8_;
1569 : const T9 v9_;
1570 : const T10 v10_;
1571 : const T11 v11_;
1572 : const T12 v12_;
1573 : const T13 v13_;
1574 : const T14 v14_;
1575 : const T15 v15_;
1576 : const T16 v16_;
1577 : const T17 v17_;
1578 : const T18 v18_;
1579 : const T19 v19_;
1580 : const T20 v20_;
1581 : const T21 v21_;
1582 : const T22 v22_;
1583 : const T23 v23_;
1584 : const T24 v24_;
1585 : const T25 v25_;
1586 : const T26 v26_;
1587 : const T27 v27_;
1588 : const T28 v28_;
1589 : const T29 v29_;
1590 : const T30 v30_;
1591 : const T31 v31_;
1592 : const T32 v32_;
1593 : const T33 v33_;
1594 : };
1595 :
1596 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
1597 : typename T6, typename T7, typename T8, typename T9, typename T10,
1598 : typename T11, typename T12, typename T13, typename T14, typename T15,
1599 : typename T16, typename T17, typename T18, typename T19, typename T20,
1600 : typename T21, typename T22, typename T23, typename T24, typename T25,
1601 : typename T26, typename T27, typename T28, typename T29, typename T30,
1602 : typename T31, typename T32, typename T33, typename T34>
1603 : class ValueArray34 {
1604 : public:
1605 : ValueArray34(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
1606 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
1607 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
1608 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
1609 : T34 v34) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
1610 : v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
1611 : v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
1612 : v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
1613 : v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
1614 : v33_(v33), v34_(v34) {}
1615 :
1616 : template <typename T>
1617 : operator ParamGenerator<T>() const {
1618 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
1619 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
1620 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
1621 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
1622 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
1623 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
1624 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
1625 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
1626 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
1627 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
1628 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
1629 : static_cast<T>(v33_), static_cast<T>(v34_)};
1630 : return ValuesIn(array);
1631 : }
1632 :
1633 : private:
1634 : // No implementation - assignment is unsupported.
1635 : void operator=(const ValueArray34& other);
1636 :
1637 : const T1 v1_;
1638 : const T2 v2_;
1639 : const T3 v3_;
1640 : const T4 v4_;
1641 : const T5 v5_;
1642 : const T6 v6_;
1643 : const T7 v7_;
1644 : const T8 v8_;
1645 : const T9 v9_;
1646 : const T10 v10_;
1647 : const T11 v11_;
1648 : const T12 v12_;
1649 : const T13 v13_;
1650 : const T14 v14_;
1651 : const T15 v15_;
1652 : const T16 v16_;
1653 : const T17 v17_;
1654 : const T18 v18_;
1655 : const T19 v19_;
1656 : const T20 v20_;
1657 : const T21 v21_;
1658 : const T22 v22_;
1659 : const T23 v23_;
1660 : const T24 v24_;
1661 : const T25 v25_;
1662 : const T26 v26_;
1663 : const T27 v27_;
1664 : const T28 v28_;
1665 : const T29 v29_;
1666 : const T30 v30_;
1667 : const T31 v31_;
1668 : const T32 v32_;
1669 : const T33 v33_;
1670 : const T34 v34_;
1671 : };
1672 :
1673 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
1674 : typename T6, typename T7, typename T8, typename T9, typename T10,
1675 : typename T11, typename T12, typename T13, typename T14, typename T15,
1676 : typename T16, typename T17, typename T18, typename T19, typename T20,
1677 : typename T21, typename T22, typename T23, typename T24, typename T25,
1678 : typename T26, typename T27, typename T28, typename T29, typename T30,
1679 : typename T31, typename T32, typename T33, typename T34, typename T35>
1680 : class ValueArray35 {
1681 : public:
1682 : ValueArray35(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
1683 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
1684 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
1685 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
1686 : T34 v34, T35 v35) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
1687 : v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
1688 : v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
1689 : v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
1690 : v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
1691 : v32_(v32), v33_(v33), v34_(v34), v35_(v35) {}
1692 :
1693 : template <typename T>
1694 : operator ParamGenerator<T>() const {
1695 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
1696 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
1697 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
1698 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
1699 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
1700 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
1701 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
1702 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
1703 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
1704 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
1705 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
1706 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_)};
1707 : return ValuesIn(array);
1708 : }
1709 :
1710 : private:
1711 : // No implementation - assignment is unsupported.
1712 : void operator=(const ValueArray35& other);
1713 :
1714 : const T1 v1_;
1715 : const T2 v2_;
1716 : const T3 v3_;
1717 : const T4 v4_;
1718 : const T5 v5_;
1719 : const T6 v6_;
1720 : const T7 v7_;
1721 : const T8 v8_;
1722 : const T9 v9_;
1723 : const T10 v10_;
1724 : const T11 v11_;
1725 : const T12 v12_;
1726 : const T13 v13_;
1727 : const T14 v14_;
1728 : const T15 v15_;
1729 : const T16 v16_;
1730 : const T17 v17_;
1731 : const T18 v18_;
1732 : const T19 v19_;
1733 : const T20 v20_;
1734 : const T21 v21_;
1735 : const T22 v22_;
1736 : const T23 v23_;
1737 : const T24 v24_;
1738 : const T25 v25_;
1739 : const T26 v26_;
1740 : const T27 v27_;
1741 : const T28 v28_;
1742 : const T29 v29_;
1743 : const T30 v30_;
1744 : const T31 v31_;
1745 : const T32 v32_;
1746 : const T33 v33_;
1747 : const T34 v34_;
1748 : const T35 v35_;
1749 : };
1750 :
1751 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
1752 : typename T6, typename T7, typename T8, typename T9, typename T10,
1753 : typename T11, typename T12, typename T13, typename T14, typename T15,
1754 : typename T16, typename T17, typename T18, typename T19, typename T20,
1755 : typename T21, typename T22, typename T23, typename T24, typename T25,
1756 : typename T26, typename T27, typename T28, typename T29, typename T30,
1757 : typename T31, typename T32, typename T33, typename T34, typename T35,
1758 : typename T36>
1759 : class ValueArray36 {
1760 : public:
1761 : ValueArray36(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
1762 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
1763 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
1764 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
1765 : T34 v34, T35 v35, T36 v36) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
1766 : v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
1767 : v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
1768 : v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
1769 : v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
1770 : v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36) {}
1771 :
1772 : template <typename T>
1773 : operator ParamGenerator<T>() const {
1774 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
1775 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
1776 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
1777 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
1778 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
1779 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
1780 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
1781 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
1782 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
1783 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
1784 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
1785 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
1786 : static_cast<T>(v36_)};
1787 : return ValuesIn(array);
1788 : }
1789 :
1790 : private:
1791 : // No implementation - assignment is unsupported.
1792 : void operator=(const ValueArray36& other);
1793 :
1794 : const T1 v1_;
1795 : const T2 v2_;
1796 : const T3 v3_;
1797 : const T4 v4_;
1798 : const T5 v5_;
1799 : const T6 v6_;
1800 : const T7 v7_;
1801 : const T8 v8_;
1802 : const T9 v9_;
1803 : const T10 v10_;
1804 : const T11 v11_;
1805 : const T12 v12_;
1806 : const T13 v13_;
1807 : const T14 v14_;
1808 : const T15 v15_;
1809 : const T16 v16_;
1810 : const T17 v17_;
1811 : const T18 v18_;
1812 : const T19 v19_;
1813 : const T20 v20_;
1814 : const T21 v21_;
1815 : const T22 v22_;
1816 : const T23 v23_;
1817 : const T24 v24_;
1818 : const T25 v25_;
1819 : const T26 v26_;
1820 : const T27 v27_;
1821 : const T28 v28_;
1822 : const T29 v29_;
1823 : const T30 v30_;
1824 : const T31 v31_;
1825 : const T32 v32_;
1826 : const T33 v33_;
1827 : const T34 v34_;
1828 : const T35 v35_;
1829 : const T36 v36_;
1830 : };
1831 :
1832 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
1833 : typename T6, typename T7, typename T8, typename T9, typename T10,
1834 : typename T11, typename T12, typename T13, typename T14, typename T15,
1835 : typename T16, typename T17, typename T18, typename T19, typename T20,
1836 : typename T21, typename T22, typename T23, typename T24, typename T25,
1837 : typename T26, typename T27, typename T28, typename T29, typename T30,
1838 : typename T31, typename T32, typename T33, typename T34, typename T35,
1839 : typename T36, typename T37>
1840 : class ValueArray37 {
1841 : public:
1842 : ValueArray37(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
1843 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
1844 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
1845 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
1846 : T34 v34, T35 v35, T36 v36, T37 v37) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
1847 : v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
1848 : v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
1849 : v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
1850 : v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
1851 : v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
1852 : v36_(v36), v37_(v37) {}
1853 :
1854 : template <typename T>
1855 : operator ParamGenerator<T>() const {
1856 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
1857 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
1858 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
1859 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
1860 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
1861 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
1862 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
1863 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
1864 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
1865 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
1866 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
1867 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
1868 : static_cast<T>(v36_), static_cast<T>(v37_)};
1869 : return ValuesIn(array);
1870 : }
1871 :
1872 : private:
1873 : // No implementation - assignment is unsupported.
1874 : void operator=(const ValueArray37& other);
1875 :
1876 : const T1 v1_;
1877 : const T2 v2_;
1878 : const T3 v3_;
1879 : const T4 v4_;
1880 : const T5 v5_;
1881 : const T6 v6_;
1882 : const T7 v7_;
1883 : const T8 v8_;
1884 : const T9 v9_;
1885 : const T10 v10_;
1886 : const T11 v11_;
1887 : const T12 v12_;
1888 : const T13 v13_;
1889 : const T14 v14_;
1890 : const T15 v15_;
1891 : const T16 v16_;
1892 : const T17 v17_;
1893 : const T18 v18_;
1894 : const T19 v19_;
1895 : const T20 v20_;
1896 : const T21 v21_;
1897 : const T22 v22_;
1898 : const T23 v23_;
1899 : const T24 v24_;
1900 : const T25 v25_;
1901 : const T26 v26_;
1902 : const T27 v27_;
1903 : const T28 v28_;
1904 : const T29 v29_;
1905 : const T30 v30_;
1906 : const T31 v31_;
1907 : const T32 v32_;
1908 : const T33 v33_;
1909 : const T34 v34_;
1910 : const T35 v35_;
1911 : const T36 v36_;
1912 : const T37 v37_;
1913 : };
1914 :
1915 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
1916 : typename T6, typename T7, typename T8, typename T9, typename T10,
1917 : typename T11, typename T12, typename T13, typename T14, typename T15,
1918 : typename T16, typename T17, typename T18, typename T19, typename T20,
1919 : typename T21, typename T22, typename T23, typename T24, typename T25,
1920 : typename T26, typename T27, typename T28, typename T29, typename T30,
1921 : typename T31, typename T32, typename T33, typename T34, typename T35,
1922 : typename T36, typename T37, typename T38>
1923 : class ValueArray38 {
1924 : public:
1925 : ValueArray38(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
1926 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
1927 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
1928 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
1929 : T34 v34, T35 v35, T36 v36, T37 v37, T38 v38) : v1_(v1), v2_(v2), v3_(v3),
1930 : v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
1931 : v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
1932 : v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
1933 : v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
1934 : v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
1935 : v35_(v35), v36_(v36), v37_(v37), v38_(v38) {}
1936 :
1937 : template <typename T>
1938 : operator ParamGenerator<T>() const {
1939 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
1940 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
1941 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
1942 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
1943 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
1944 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
1945 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
1946 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
1947 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
1948 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
1949 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
1950 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
1951 : static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_)};
1952 : return ValuesIn(array);
1953 : }
1954 :
1955 : private:
1956 : // No implementation - assignment is unsupported.
1957 : void operator=(const ValueArray38& other);
1958 :
1959 : const T1 v1_;
1960 : const T2 v2_;
1961 : const T3 v3_;
1962 : const T4 v4_;
1963 : const T5 v5_;
1964 : const T6 v6_;
1965 : const T7 v7_;
1966 : const T8 v8_;
1967 : const T9 v9_;
1968 : const T10 v10_;
1969 : const T11 v11_;
1970 : const T12 v12_;
1971 : const T13 v13_;
1972 : const T14 v14_;
1973 : const T15 v15_;
1974 : const T16 v16_;
1975 : const T17 v17_;
1976 : const T18 v18_;
1977 : const T19 v19_;
1978 : const T20 v20_;
1979 : const T21 v21_;
1980 : const T22 v22_;
1981 : const T23 v23_;
1982 : const T24 v24_;
1983 : const T25 v25_;
1984 : const T26 v26_;
1985 : const T27 v27_;
1986 : const T28 v28_;
1987 : const T29 v29_;
1988 : const T30 v30_;
1989 : const T31 v31_;
1990 : const T32 v32_;
1991 : const T33 v33_;
1992 : const T34 v34_;
1993 : const T35 v35_;
1994 : const T36 v36_;
1995 : const T37 v37_;
1996 : const T38 v38_;
1997 : };
1998 :
1999 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
2000 : typename T6, typename T7, typename T8, typename T9, typename T10,
2001 : typename T11, typename T12, typename T13, typename T14, typename T15,
2002 : typename T16, typename T17, typename T18, typename T19, typename T20,
2003 : typename T21, typename T22, typename T23, typename T24, typename T25,
2004 : typename T26, typename T27, typename T28, typename T29, typename T30,
2005 : typename T31, typename T32, typename T33, typename T34, typename T35,
2006 : typename T36, typename T37, typename T38, typename T39>
2007 : class ValueArray39 {
2008 : public:
2009 : ValueArray39(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
2010 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
2011 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
2012 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
2013 : T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39) : v1_(v1), v2_(v2),
2014 : v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
2015 : v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
2016 : v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
2017 : v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
2018 : v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
2019 : v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39) {}
2020 :
2021 : template <typename T>
2022 : operator ParamGenerator<T>() const {
2023 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
2024 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
2025 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
2026 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
2027 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
2028 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
2029 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
2030 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
2031 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
2032 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
2033 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
2034 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
2035 : static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
2036 : static_cast<T>(v39_)};
2037 : return ValuesIn(array);
2038 : }
2039 :
2040 : private:
2041 : // No implementation - assignment is unsupported.
2042 : void operator=(const ValueArray39& other);
2043 :
2044 : const T1 v1_;
2045 : const T2 v2_;
2046 : const T3 v3_;
2047 : const T4 v4_;
2048 : const T5 v5_;
2049 : const T6 v6_;
2050 : const T7 v7_;
2051 : const T8 v8_;
2052 : const T9 v9_;
2053 : const T10 v10_;
2054 : const T11 v11_;
2055 : const T12 v12_;
2056 : const T13 v13_;
2057 : const T14 v14_;
2058 : const T15 v15_;
2059 : const T16 v16_;
2060 : const T17 v17_;
2061 : const T18 v18_;
2062 : const T19 v19_;
2063 : const T20 v20_;
2064 : const T21 v21_;
2065 : const T22 v22_;
2066 : const T23 v23_;
2067 : const T24 v24_;
2068 : const T25 v25_;
2069 : const T26 v26_;
2070 : const T27 v27_;
2071 : const T28 v28_;
2072 : const T29 v29_;
2073 : const T30 v30_;
2074 : const T31 v31_;
2075 : const T32 v32_;
2076 : const T33 v33_;
2077 : const T34 v34_;
2078 : const T35 v35_;
2079 : const T36 v36_;
2080 : const T37 v37_;
2081 : const T38 v38_;
2082 : const T39 v39_;
2083 : };
2084 :
2085 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
2086 : typename T6, typename T7, typename T8, typename T9, typename T10,
2087 : typename T11, typename T12, typename T13, typename T14, typename T15,
2088 : typename T16, typename T17, typename T18, typename T19, typename T20,
2089 : typename T21, typename T22, typename T23, typename T24, typename T25,
2090 : typename T26, typename T27, typename T28, typename T29, typename T30,
2091 : typename T31, typename T32, typename T33, typename T34, typename T35,
2092 : typename T36, typename T37, typename T38, typename T39, typename T40>
2093 : class ValueArray40 {
2094 : public:
2095 : ValueArray40(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
2096 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
2097 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
2098 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
2099 : T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) : v1_(v1),
2100 : v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
2101 : v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
2102 : v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
2103 : v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
2104 : v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
2105 : v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
2106 : v40_(v40) {}
2107 :
2108 : template <typename T>
2109 : operator ParamGenerator<T>() const {
2110 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
2111 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
2112 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
2113 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
2114 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
2115 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
2116 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
2117 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
2118 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
2119 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
2120 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
2121 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
2122 : static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
2123 : static_cast<T>(v39_), static_cast<T>(v40_)};
2124 : return ValuesIn(array);
2125 : }
2126 :
2127 : private:
2128 : // No implementation - assignment is unsupported.
2129 : void operator=(const ValueArray40& other);
2130 :
2131 : const T1 v1_;
2132 : const T2 v2_;
2133 : const T3 v3_;
2134 : const T4 v4_;
2135 : const T5 v5_;
2136 : const T6 v6_;
2137 : const T7 v7_;
2138 : const T8 v8_;
2139 : const T9 v9_;
2140 : const T10 v10_;
2141 : const T11 v11_;
2142 : const T12 v12_;
2143 : const T13 v13_;
2144 : const T14 v14_;
2145 : const T15 v15_;
2146 : const T16 v16_;
2147 : const T17 v17_;
2148 : const T18 v18_;
2149 : const T19 v19_;
2150 : const T20 v20_;
2151 : const T21 v21_;
2152 : const T22 v22_;
2153 : const T23 v23_;
2154 : const T24 v24_;
2155 : const T25 v25_;
2156 : const T26 v26_;
2157 : const T27 v27_;
2158 : const T28 v28_;
2159 : const T29 v29_;
2160 : const T30 v30_;
2161 : const T31 v31_;
2162 : const T32 v32_;
2163 : const T33 v33_;
2164 : const T34 v34_;
2165 : const T35 v35_;
2166 : const T36 v36_;
2167 : const T37 v37_;
2168 : const T38 v38_;
2169 : const T39 v39_;
2170 : const T40 v40_;
2171 : };
2172 :
2173 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
2174 : typename T6, typename T7, typename T8, typename T9, typename T10,
2175 : typename T11, typename T12, typename T13, typename T14, typename T15,
2176 : typename T16, typename T17, typename T18, typename T19, typename T20,
2177 : typename T21, typename T22, typename T23, typename T24, typename T25,
2178 : typename T26, typename T27, typename T28, typename T29, typename T30,
2179 : typename T31, typename T32, typename T33, typename T34, typename T35,
2180 : typename T36, typename T37, typename T38, typename T39, typename T40,
2181 : typename T41>
2182 : class ValueArray41 {
2183 : public:
2184 : ValueArray41(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
2185 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
2186 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
2187 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
2188 : T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40,
2189 : T41 v41) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
2190 : v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
2191 : v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
2192 : v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
2193 : v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
2194 : v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
2195 : v39_(v39), v40_(v40), v41_(v41) {}
2196 :
2197 : template <typename T>
2198 : operator ParamGenerator<T>() const {
2199 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
2200 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
2201 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
2202 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
2203 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
2204 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
2205 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
2206 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
2207 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
2208 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
2209 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
2210 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
2211 : static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
2212 : static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_)};
2213 : return ValuesIn(array);
2214 : }
2215 :
2216 : private:
2217 : // No implementation - assignment is unsupported.
2218 : void operator=(const ValueArray41& other);
2219 :
2220 : const T1 v1_;
2221 : const T2 v2_;
2222 : const T3 v3_;
2223 : const T4 v4_;
2224 : const T5 v5_;
2225 : const T6 v6_;
2226 : const T7 v7_;
2227 : const T8 v8_;
2228 : const T9 v9_;
2229 : const T10 v10_;
2230 : const T11 v11_;
2231 : const T12 v12_;
2232 : const T13 v13_;
2233 : const T14 v14_;
2234 : const T15 v15_;
2235 : const T16 v16_;
2236 : const T17 v17_;
2237 : const T18 v18_;
2238 : const T19 v19_;
2239 : const T20 v20_;
2240 : const T21 v21_;
2241 : const T22 v22_;
2242 : const T23 v23_;
2243 : const T24 v24_;
2244 : const T25 v25_;
2245 : const T26 v26_;
2246 : const T27 v27_;
2247 : const T28 v28_;
2248 : const T29 v29_;
2249 : const T30 v30_;
2250 : const T31 v31_;
2251 : const T32 v32_;
2252 : const T33 v33_;
2253 : const T34 v34_;
2254 : const T35 v35_;
2255 : const T36 v36_;
2256 : const T37 v37_;
2257 : const T38 v38_;
2258 : const T39 v39_;
2259 : const T40 v40_;
2260 : const T41 v41_;
2261 : };
2262 :
2263 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
2264 : typename T6, typename T7, typename T8, typename T9, typename T10,
2265 : typename T11, typename T12, typename T13, typename T14, typename T15,
2266 : typename T16, typename T17, typename T18, typename T19, typename T20,
2267 : typename T21, typename T22, typename T23, typename T24, typename T25,
2268 : typename T26, typename T27, typename T28, typename T29, typename T30,
2269 : typename T31, typename T32, typename T33, typename T34, typename T35,
2270 : typename T36, typename T37, typename T38, typename T39, typename T40,
2271 : typename T41, typename T42>
2272 : class ValueArray42 {
2273 : public:
2274 : ValueArray42(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
2275 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
2276 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
2277 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
2278 : T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
2279 : T42 v42) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
2280 : v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
2281 : v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
2282 : v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
2283 : v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
2284 : v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
2285 : v39_(v39), v40_(v40), v41_(v41), v42_(v42) {}
2286 :
2287 : template <typename T>
2288 : operator ParamGenerator<T>() const {
2289 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
2290 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
2291 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
2292 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
2293 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
2294 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
2295 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
2296 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
2297 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
2298 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
2299 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
2300 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
2301 : static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
2302 : static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
2303 : static_cast<T>(v42_)};
2304 : return ValuesIn(array);
2305 : }
2306 :
2307 : private:
2308 : // No implementation - assignment is unsupported.
2309 : void operator=(const ValueArray42& other);
2310 :
2311 : const T1 v1_;
2312 : const T2 v2_;
2313 : const T3 v3_;
2314 : const T4 v4_;
2315 : const T5 v5_;
2316 : const T6 v6_;
2317 : const T7 v7_;
2318 : const T8 v8_;
2319 : const T9 v9_;
2320 : const T10 v10_;
2321 : const T11 v11_;
2322 : const T12 v12_;
2323 : const T13 v13_;
2324 : const T14 v14_;
2325 : const T15 v15_;
2326 : const T16 v16_;
2327 : const T17 v17_;
2328 : const T18 v18_;
2329 : const T19 v19_;
2330 : const T20 v20_;
2331 : const T21 v21_;
2332 : const T22 v22_;
2333 : const T23 v23_;
2334 : const T24 v24_;
2335 : const T25 v25_;
2336 : const T26 v26_;
2337 : const T27 v27_;
2338 : const T28 v28_;
2339 : const T29 v29_;
2340 : const T30 v30_;
2341 : const T31 v31_;
2342 : const T32 v32_;
2343 : const T33 v33_;
2344 : const T34 v34_;
2345 : const T35 v35_;
2346 : const T36 v36_;
2347 : const T37 v37_;
2348 : const T38 v38_;
2349 : const T39 v39_;
2350 : const T40 v40_;
2351 : const T41 v41_;
2352 : const T42 v42_;
2353 : };
2354 :
2355 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
2356 : typename T6, typename T7, typename T8, typename T9, typename T10,
2357 : typename T11, typename T12, typename T13, typename T14, typename T15,
2358 : typename T16, typename T17, typename T18, typename T19, typename T20,
2359 : typename T21, typename T22, typename T23, typename T24, typename T25,
2360 : typename T26, typename T27, typename T28, typename T29, typename T30,
2361 : typename T31, typename T32, typename T33, typename T34, typename T35,
2362 : typename T36, typename T37, typename T38, typename T39, typename T40,
2363 : typename T41, typename T42, typename T43>
2364 : class ValueArray43 {
2365 : public:
2366 : ValueArray43(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
2367 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
2368 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
2369 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
2370 : T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
2371 : T42 v42, T43 v43) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
2372 : v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
2373 : v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
2374 : v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
2375 : v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
2376 : v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37),
2377 : v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43) {}
2378 :
2379 : template <typename T>
2380 : operator ParamGenerator<T>() const {
2381 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
2382 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
2383 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
2384 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
2385 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
2386 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
2387 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
2388 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
2389 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
2390 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
2391 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
2392 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
2393 : static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
2394 : static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
2395 : static_cast<T>(v42_), static_cast<T>(v43_)};
2396 : return ValuesIn(array);
2397 : }
2398 :
2399 : private:
2400 : // No implementation - assignment is unsupported.
2401 : void operator=(const ValueArray43& other);
2402 :
2403 : const T1 v1_;
2404 : const T2 v2_;
2405 : const T3 v3_;
2406 : const T4 v4_;
2407 : const T5 v5_;
2408 : const T6 v6_;
2409 : const T7 v7_;
2410 : const T8 v8_;
2411 : const T9 v9_;
2412 : const T10 v10_;
2413 : const T11 v11_;
2414 : const T12 v12_;
2415 : const T13 v13_;
2416 : const T14 v14_;
2417 : const T15 v15_;
2418 : const T16 v16_;
2419 : const T17 v17_;
2420 : const T18 v18_;
2421 : const T19 v19_;
2422 : const T20 v20_;
2423 : const T21 v21_;
2424 : const T22 v22_;
2425 : const T23 v23_;
2426 : const T24 v24_;
2427 : const T25 v25_;
2428 : const T26 v26_;
2429 : const T27 v27_;
2430 : const T28 v28_;
2431 : const T29 v29_;
2432 : const T30 v30_;
2433 : const T31 v31_;
2434 : const T32 v32_;
2435 : const T33 v33_;
2436 : const T34 v34_;
2437 : const T35 v35_;
2438 : const T36 v36_;
2439 : const T37 v37_;
2440 : const T38 v38_;
2441 : const T39 v39_;
2442 : const T40 v40_;
2443 : const T41 v41_;
2444 : const T42 v42_;
2445 : const T43 v43_;
2446 : };
2447 :
2448 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
2449 : typename T6, typename T7, typename T8, typename T9, typename T10,
2450 : typename T11, typename T12, typename T13, typename T14, typename T15,
2451 : typename T16, typename T17, typename T18, typename T19, typename T20,
2452 : typename T21, typename T22, typename T23, typename T24, typename T25,
2453 : typename T26, typename T27, typename T28, typename T29, typename T30,
2454 : typename T31, typename T32, typename T33, typename T34, typename T35,
2455 : typename T36, typename T37, typename T38, typename T39, typename T40,
2456 : typename T41, typename T42, typename T43, typename T44>
2457 : class ValueArray44 {
2458 : public:
2459 : ValueArray44(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
2460 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
2461 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
2462 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
2463 : T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
2464 : T42 v42, T43 v43, T44 v44) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
2465 : v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
2466 : v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
2467 : v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
2468 : v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
2469 : v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36),
2470 : v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42),
2471 : v43_(v43), v44_(v44) {}
2472 :
2473 : template <typename T>
2474 : operator ParamGenerator<T>() const {
2475 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
2476 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
2477 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
2478 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
2479 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
2480 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
2481 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
2482 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
2483 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
2484 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
2485 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
2486 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
2487 : static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
2488 : static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
2489 : static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_)};
2490 : return ValuesIn(array);
2491 : }
2492 :
2493 : private:
2494 : // No implementation - assignment is unsupported.
2495 : void operator=(const ValueArray44& other);
2496 :
2497 : const T1 v1_;
2498 : const T2 v2_;
2499 : const T3 v3_;
2500 : const T4 v4_;
2501 : const T5 v5_;
2502 : const T6 v6_;
2503 : const T7 v7_;
2504 : const T8 v8_;
2505 : const T9 v9_;
2506 : const T10 v10_;
2507 : const T11 v11_;
2508 : const T12 v12_;
2509 : const T13 v13_;
2510 : const T14 v14_;
2511 : const T15 v15_;
2512 : const T16 v16_;
2513 : const T17 v17_;
2514 : const T18 v18_;
2515 : const T19 v19_;
2516 : const T20 v20_;
2517 : const T21 v21_;
2518 : const T22 v22_;
2519 : const T23 v23_;
2520 : const T24 v24_;
2521 : const T25 v25_;
2522 : const T26 v26_;
2523 : const T27 v27_;
2524 : const T28 v28_;
2525 : const T29 v29_;
2526 : const T30 v30_;
2527 : const T31 v31_;
2528 : const T32 v32_;
2529 : const T33 v33_;
2530 : const T34 v34_;
2531 : const T35 v35_;
2532 : const T36 v36_;
2533 : const T37 v37_;
2534 : const T38 v38_;
2535 : const T39 v39_;
2536 : const T40 v40_;
2537 : const T41 v41_;
2538 : const T42 v42_;
2539 : const T43 v43_;
2540 : const T44 v44_;
2541 : };
2542 :
2543 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
2544 : typename T6, typename T7, typename T8, typename T9, typename T10,
2545 : typename T11, typename T12, typename T13, typename T14, typename T15,
2546 : typename T16, typename T17, typename T18, typename T19, typename T20,
2547 : typename T21, typename T22, typename T23, typename T24, typename T25,
2548 : typename T26, typename T27, typename T28, typename T29, typename T30,
2549 : typename T31, typename T32, typename T33, typename T34, typename T35,
2550 : typename T36, typename T37, typename T38, typename T39, typename T40,
2551 : typename T41, typename T42, typename T43, typename T44, typename T45>
2552 : class ValueArray45 {
2553 : public:
2554 : ValueArray45(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
2555 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
2556 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
2557 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
2558 : T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
2559 : T42 v42, T43 v43, T44 v44, T45 v45) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
2560 : v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
2561 : v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
2562 : v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
2563 : v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
2564 : v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
2565 : v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41),
2566 : v42_(v42), v43_(v43), v44_(v44), v45_(v45) {}
2567 :
2568 : template <typename T>
2569 : operator ParamGenerator<T>() const {
2570 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
2571 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
2572 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
2573 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
2574 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
2575 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
2576 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
2577 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
2578 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
2579 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
2580 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
2581 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
2582 : static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
2583 : static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
2584 : static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
2585 : static_cast<T>(v45_)};
2586 : return ValuesIn(array);
2587 : }
2588 :
2589 : private:
2590 : // No implementation - assignment is unsupported.
2591 : void operator=(const ValueArray45& other);
2592 :
2593 : const T1 v1_;
2594 : const T2 v2_;
2595 : const T3 v3_;
2596 : const T4 v4_;
2597 : const T5 v5_;
2598 : const T6 v6_;
2599 : const T7 v7_;
2600 : const T8 v8_;
2601 : const T9 v9_;
2602 : const T10 v10_;
2603 : const T11 v11_;
2604 : const T12 v12_;
2605 : const T13 v13_;
2606 : const T14 v14_;
2607 : const T15 v15_;
2608 : const T16 v16_;
2609 : const T17 v17_;
2610 : const T18 v18_;
2611 : const T19 v19_;
2612 : const T20 v20_;
2613 : const T21 v21_;
2614 : const T22 v22_;
2615 : const T23 v23_;
2616 : const T24 v24_;
2617 : const T25 v25_;
2618 : const T26 v26_;
2619 : const T27 v27_;
2620 : const T28 v28_;
2621 : const T29 v29_;
2622 : const T30 v30_;
2623 : const T31 v31_;
2624 : const T32 v32_;
2625 : const T33 v33_;
2626 : const T34 v34_;
2627 : const T35 v35_;
2628 : const T36 v36_;
2629 : const T37 v37_;
2630 : const T38 v38_;
2631 : const T39 v39_;
2632 : const T40 v40_;
2633 : const T41 v41_;
2634 : const T42 v42_;
2635 : const T43 v43_;
2636 : const T44 v44_;
2637 : const T45 v45_;
2638 : };
2639 :
2640 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
2641 : typename T6, typename T7, typename T8, typename T9, typename T10,
2642 : typename T11, typename T12, typename T13, typename T14, typename T15,
2643 : typename T16, typename T17, typename T18, typename T19, typename T20,
2644 : typename T21, typename T22, typename T23, typename T24, typename T25,
2645 : typename T26, typename T27, typename T28, typename T29, typename T30,
2646 : typename T31, typename T32, typename T33, typename T34, typename T35,
2647 : typename T36, typename T37, typename T38, typename T39, typename T40,
2648 : typename T41, typename T42, typename T43, typename T44, typename T45,
2649 : typename T46>
2650 : class ValueArray46 {
2651 : public:
2652 : ValueArray46(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
2653 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
2654 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
2655 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
2656 : T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
2657 : T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) : v1_(v1), v2_(v2), v3_(v3),
2658 : v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
2659 : v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
2660 : v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
2661 : v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
2662 : v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
2663 : v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
2664 : v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46) {}
2665 :
2666 : template <typename T>
2667 : operator ParamGenerator<T>() const {
2668 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
2669 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
2670 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
2671 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
2672 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
2673 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
2674 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
2675 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
2676 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
2677 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
2678 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
2679 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
2680 : static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
2681 : static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
2682 : static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
2683 : static_cast<T>(v45_), static_cast<T>(v46_)};
2684 : return ValuesIn(array);
2685 : }
2686 :
2687 : private:
2688 : // No implementation - assignment is unsupported.
2689 : void operator=(const ValueArray46& other);
2690 :
2691 : const T1 v1_;
2692 : const T2 v2_;
2693 : const T3 v3_;
2694 : const T4 v4_;
2695 : const T5 v5_;
2696 : const T6 v6_;
2697 : const T7 v7_;
2698 : const T8 v8_;
2699 : const T9 v9_;
2700 : const T10 v10_;
2701 : const T11 v11_;
2702 : const T12 v12_;
2703 : const T13 v13_;
2704 : const T14 v14_;
2705 : const T15 v15_;
2706 : const T16 v16_;
2707 : const T17 v17_;
2708 : const T18 v18_;
2709 : const T19 v19_;
2710 : const T20 v20_;
2711 : const T21 v21_;
2712 : const T22 v22_;
2713 : const T23 v23_;
2714 : const T24 v24_;
2715 : const T25 v25_;
2716 : const T26 v26_;
2717 : const T27 v27_;
2718 : const T28 v28_;
2719 : const T29 v29_;
2720 : const T30 v30_;
2721 : const T31 v31_;
2722 : const T32 v32_;
2723 : const T33 v33_;
2724 : const T34 v34_;
2725 : const T35 v35_;
2726 : const T36 v36_;
2727 : const T37 v37_;
2728 : const T38 v38_;
2729 : const T39 v39_;
2730 : const T40 v40_;
2731 : const T41 v41_;
2732 : const T42 v42_;
2733 : const T43 v43_;
2734 : const T44 v44_;
2735 : const T45 v45_;
2736 : const T46 v46_;
2737 : };
2738 :
2739 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
2740 : typename T6, typename T7, typename T8, typename T9, typename T10,
2741 : typename T11, typename T12, typename T13, typename T14, typename T15,
2742 : typename T16, typename T17, typename T18, typename T19, typename T20,
2743 : typename T21, typename T22, typename T23, typename T24, typename T25,
2744 : typename T26, typename T27, typename T28, typename T29, typename T30,
2745 : typename T31, typename T32, typename T33, typename T34, typename T35,
2746 : typename T36, typename T37, typename T38, typename T39, typename T40,
2747 : typename T41, typename T42, typename T43, typename T44, typename T45,
2748 : typename T46, typename T47>
2749 : class ValueArray47 {
2750 : public:
2751 : ValueArray47(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
2752 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
2753 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
2754 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
2755 : T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
2756 : T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) : v1_(v1), v2_(v2),
2757 : v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
2758 : v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
2759 : v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
2760 : v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
2761 : v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
2762 : v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
2763 : v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46),
2764 : v47_(v47) {}
2765 :
2766 : template <typename T>
2767 : operator ParamGenerator<T>() const {
2768 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
2769 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
2770 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
2771 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
2772 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
2773 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
2774 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
2775 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
2776 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
2777 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
2778 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
2779 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
2780 : static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
2781 : static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
2782 : static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
2783 : static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_)};
2784 : return ValuesIn(array);
2785 : }
2786 :
2787 : private:
2788 : // No implementation - assignment is unsupported.
2789 : void operator=(const ValueArray47& other);
2790 :
2791 : const T1 v1_;
2792 : const T2 v2_;
2793 : const T3 v3_;
2794 : const T4 v4_;
2795 : const T5 v5_;
2796 : const T6 v6_;
2797 : const T7 v7_;
2798 : const T8 v8_;
2799 : const T9 v9_;
2800 : const T10 v10_;
2801 : const T11 v11_;
2802 : const T12 v12_;
2803 : const T13 v13_;
2804 : const T14 v14_;
2805 : const T15 v15_;
2806 : const T16 v16_;
2807 : const T17 v17_;
2808 : const T18 v18_;
2809 : const T19 v19_;
2810 : const T20 v20_;
2811 : const T21 v21_;
2812 : const T22 v22_;
2813 : const T23 v23_;
2814 : const T24 v24_;
2815 : const T25 v25_;
2816 : const T26 v26_;
2817 : const T27 v27_;
2818 : const T28 v28_;
2819 : const T29 v29_;
2820 : const T30 v30_;
2821 : const T31 v31_;
2822 : const T32 v32_;
2823 : const T33 v33_;
2824 : const T34 v34_;
2825 : const T35 v35_;
2826 : const T36 v36_;
2827 : const T37 v37_;
2828 : const T38 v38_;
2829 : const T39 v39_;
2830 : const T40 v40_;
2831 : const T41 v41_;
2832 : const T42 v42_;
2833 : const T43 v43_;
2834 : const T44 v44_;
2835 : const T45 v45_;
2836 : const T46 v46_;
2837 : const T47 v47_;
2838 : };
2839 :
2840 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
2841 : typename T6, typename T7, typename T8, typename T9, typename T10,
2842 : typename T11, typename T12, typename T13, typename T14, typename T15,
2843 : typename T16, typename T17, typename T18, typename T19, typename T20,
2844 : typename T21, typename T22, typename T23, typename T24, typename T25,
2845 : typename T26, typename T27, typename T28, typename T29, typename T30,
2846 : typename T31, typename T32, typename T33, typename T34, typename T35,
2847 : typename T36, typename T37, typename T38, typename T39, typename T40,
2848 : typename T41, typename T42, typename T43, typename T44, typename T45,
2849 : typename T46, typename T47, typename T48>
2850 : class ValueArray48 {
2851 : public:
2852 : ValueArray48(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
2853 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
2854 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
2855 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
2856 : T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
2857 : T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48) : v1_(v1),
2858 : v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
2859 : v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
2860 : v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
2861 : v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
2862 : v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
2863 : v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
2864 : v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45),
2865 : v46_(v46), v47_(v47), v48_(v48) {}
2866 :
2867 : template <typename T>
2868 : operator ParamGenerator<T>() const {
2869 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
2870 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
2871 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
2872 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
2873 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
2874 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
2875 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
2876 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
2877 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
2878 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
2879 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
2880 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
2881 : static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
2882 : static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
2883 : static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
2884 : static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
2885 : static_cast<T>(v48_)};
2886 : return ValuesIn(array);
2887 : }
2888 :
2889 : private:
2890 : // No implementation - assignment is unsupported.
2891 : void operator=(const ValueArray48& other);
2892 :
2893 : const T1 v1_;
2894 : const T2 v2_;
2895 : const T3 v3_;
2896 : const T4 v4_;
2897 : const T5 v5_;
2898 : const T6 v6_;
2899 : const T7 v7_;
2900 : const T8 v8_;
2901 : const T9 v9_;
2902 : const T10 v10_;
2903 : const T11 v11_;
2904 : const T12 v12_;
2905 : const T13 v13_;
2906 : const T14 v14_;
2907 : const T15 v15_;
2908 : const T16 v16_;
2909 : const T17 v17_;
2910 : const T18 v18_;
2911 : const T19 v19_;
2912 : const T20 v20_;
2913 : const T21 v21_;
2914 : const T22 v22_;
2915 : const T23 v23_;
2916 : const T24 v24_;
2917 : const T25 v25_;
2918 : const T26 v26_;
2919 : const T27 v27_;
2920 : const T28 v28_;
2921 : const T29 v29_;
2922 : const T30 v30_;
2923 : const T31 v31_;
2924 : const T32 v32_;
2925 : const T33 v33_;
2926 : const T34 v34_;
2927 : const T35 v35_;
2928 : const T36 v36_;
2929 : const T37 v37_;
2930 : const T38 v38_;
2931 : const T39 v39_;
2932 : const T40 v40_;
2933 : const T41 v41_;
2934 : const T42 v42_;
2935 : const T43 v43_;
2936 : const T44 v44_;
2937 : const T45 v45_;
2938 : const T46 v46_;
2939 : const T47 v47_;
2940 : const T48 v48_;
2941 : };
2942 :
2943 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
2944 : typename T6, typename T7, typename T8, typename T9, typename T10,
2945 : typename T11, typename T12, typename T13, typename T14, typename T15,
2946 : typename T16, typename T17, typename T18, typename T19, typename T20,
2947 : typename T21, typename T22, typename T23, typename T24, typename T25,
2948 : typename T26, typename T27, typename T28, typename T29, typename T30,
2949 : typename T31, typename T32, typename T33, typename T34, typename T35,
2950 : typename T36, typename T37, typename T38, typename T39, typename T40,
2951 : typename T41, typename T42, typename T43, typename T44, typename T45,
2952 : typename T46, typename T47, typename T48, typename T49>
2953 : class ValueArray49 {
2954 : public:
2955 : ValueArray49(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
2956 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
2957 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
2958 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
2959 : T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
2960 : T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48,
2961 : T49 v49) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
2962 : v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
2963 : v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
2964 : v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
2965 : v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
2966 : v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
2967 : v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
2968 : v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49) {}
2969 :
2970 : template <typename T>
2971 : operator ParamGenerator<T>() const {
2972 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
2973 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
2974 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
2975 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
2976 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
2977 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
2978 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
2979 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
2980 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
2981 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
2982 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
2983 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
2984 : static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
2985 : static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
2986 : static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
2987 : static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
2988 : static_cast<T>(v48_), static_cast<T>(v49_)};
2989 : return ValuesIn(array);
2990 : }
2991 :
2992 : private:
2993 : // No implementation - assignment is unsupported.
2994 : void operator=(const ValueArray49& other);
2995 :
2996 : const T1 v1_;
2997 : const T2 v2_;
2998 : const T3 v3_;
2999 : const T4 v4_;
3000 : const T5 v5_;
3001 : const T6 v6_;
3002 : const T7 v7_;
3003 : const T8 v8_;
3004 : const T9 v9_;
3005 : const T10 v10_;
3006 : const T11 v11_;
3007 : const T12 v12_;
3008 : const T13 v13_;
3009 : const T14 v14_;
3010 : const T15 v15_;
3011 : const T16 v16_;
3012 : const T17 v17_;
3013 : const T18 v18_;
3014 : const T19 v19_;
3015 : const T20 v20_;
3016 : const T21 v21_;
3017 : const T22 v22_;
3018 : const T23 v23_;
3019 : const T24 v24_;
3020 : const T25 v25_;
3021 : const T26 v26_;
3022 : const T27 v27_;
3023 : const T28 v28_;
3024 : const T29 v29_;
3025 : const T30 v30_;
3026 : const T31 v31_;
3027 : const T32 v32_;
3028 : const T33 v33_;
3029 : const T34 v34_;
3030 : const T35 v35_;
3031 : const T36 v36_;
3032 : const T37 v37_;
3033 : const T38 v38_;
3034 : const T39 v39_;
3035 : const T40 v40_;
3036 : const T41 v41_;
3037 : const T42 v42_;
3038 : const T43 v43_;
3039 : const T44 v44_;
3040 : const T45 v45_;
3041 : const T46 v46_;
3042 : const T47 v47_;
3043 : const T48 v48_;
3044 : const T49 v49_;
3045 : };
3046 :
3047 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
3048 : typename T6, typename T7, typename T8, typename T9, typename T10,
3049 : typename T11, typename T12, typename T13, typename T14, typename T15,
3050 : typename T16, typename T17, typename T18, typename T19, typename T20,
3051 : typename T21, typename T22, typename T23, typename T24, typename T25,
3052 : typename T26, typename T27, typename T28, typename T29, typename T30,
3053 : typename T31, typename T32, typename T33, typename T34, typename T35,
3054 : typename T36, typename T37, typename T38, typename T39, typename T40,
3055 : typename T41, typename T42, typename T43, typename T44, typename T45,
3056 : typename T46, typename T47, typename T48, typename T49, typename T50>
3057 : class ValueArray50 {
3058 : public:
3059 : ValueArray50(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
3060 : T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
3061 : T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
3062 : T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
3063 : T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
3064 : T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, T49 v49,
3065 : T50 v50) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
3066 : v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
3067 : v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
3068 : v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
3069 : v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
3070 : v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
3071 : v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
3072 : v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49), v50_(v50) {}
3073 :
3074 : template <typename T>
3075 : operator ParamGenerator<T>() const {
3076 : const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
3077 : static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
3078 : static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
3079 : static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
3080 : static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
3081 : static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
3082 : static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
3083 : static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
3084 : static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
3085 : static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
3086 : static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
3087 : static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
3088 : static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
3089 : static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
3090 : static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
3091 : static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
3092 : static_cast<T>(v48_), static_cast<T>(v49_), static_cast<T>(v50_)};
3093 : return ValuesIn(array);
3094 : }
3095 :
3096 : private:
3097 : // No implementation - assignment is unsupported.
3098 : void operator=(const ValueArray50& other);
3099 :
3100 : const T1 v1_;
3101 : const T2 v2_;
3102 : const T3 v3_;
3103 : const T4 v4_;
3104 : const T5 v5_;
3105 : const T6 v6_;
3106 : const T7 v7_;
3107 : const T8 v8_;
3108 : const T9 v9_;
3109 : const T10 v10_;
3110 : const T11 v11_;
3111 : const T12 v12_;
3112 : const T13 v13_;
3113 : const T14 v14_;
3114 : const T15 v15_;
3115 : const T16 v16_;
3116 : const T17 v17_;
3117 : const T18 v18_;
3118 : const T19 v19_;
3119 : const T20 v20_;
3120 : const T21 v21_;
3121 : const T22 v22_;
3122 : const T23 v23_;
3123 : const T24 v24_;
3124 : const T25 v25_;
3125 : const T26 v26_;
3126 : const T27 v27_;
3127 : const T28 v28_;
3128 : const T29 v29_;
3129 : const T30 v30_;
3130 : const T31 v31_;
3131 : const T32 v32_;
3132 : const T33 v33_;
3133 : const T34 v34_;
3134 : const T35 v35_;
3135 : const T36 v36_;
3136 : const T37 v37_;
3137 : const T38 v38_;
3138 : const T39 v39_;
3139 : const T40 v40_;
3140 : const T41 v41_;
3141 : const T42 v42_;
3142 : const T43 v43_;
3143 : const T44 v44_;
3144 : const T45 v45_;
3145 : const T46 v46_;
3146 : const T47 v47_;
3147 : const T48 v48_;
3148 : const T49 v49_;
3149 : const T50 v50_;
3150 : };
3151 :
3152 : # if GTEST_HAS_COMBINE
3153 : // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
3154 : //
3155 : // Generates values from the Cartesian product of values produced
3156 : // by the argument generators.
3157 : //
3158 : template <typename T1, typename T2>
3159 : class CartesianProductGenerator2
3160 : : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2> > {
3161 : public:
3162 : typedef ::std::tr1::tuple<T1, T2> ParamType;
3163 :
3164 : CartesianProductGenerator2(const ParamGenerator<T1>& g1,
3165 : const ParamGenerator<T2>& g2)
3166 : : g1_(g1), g2_(g2) {}
3167 : virtual ~CartesianProductGenerator2() {}
3168 :
3169 : virtual ParamIteratorInterface<ParamType>* Begin() const {
3170 : return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin());
3171 : }
3172 : virtual ParamIteratorInterface<ParamType>* End() const {
3173 : return new Iterator(this, g1_, g1_.end(), g2_, g2_.end());
3174 : }
3175 :
3176 : private:
3177 : class Iterator : public ParamIteratorInterface<ParamType> {
3178 : public:
3179 : Iterator(const ParamGeneratorInterface<ParamType>* base,
3180 : const ParamGenerator<T1>& g1,
3181 : const typename ParamGenerator<T1>::iterator& current1,
3182 : const ParamGenerator<T2>& g2,
3183 : const typename ParamGenerator<T2>::iterator& current2)
3184 : : base_(base),
3185 : begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
3186 : begin2_(g2.begin()), end2_(g2.end()), current2_(current2) {
3187 : ComputeCurrentValue();
3188 : }
3189 : virtual ~Iterator() {}
3190 :
3191 : virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
3192 : return base_;
3193 : }
3194 : // Advance should not be called on beyond-of-range iterators
3195 : // so no component iterators must be beyond end of range, either.
3196 : virtual void Advance() {
3197 : assert(!AtEnd());
3198 : ++current2_;
3199 : if (current2_ == end2_) {
3200 : current2_ = begin2_;
3201 : ++current1_;
3202 : }
3203 : ComputeCurrentValue();
3204 : }
3205 : virtual ParamIteratorInterface<ParamType>* Clone() const {
3206 : return new Iterator(*this);
3207 : }
3208 : virtual const ParamType* Current() const { return ¤t_value_; }
3209 : virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
3210 : // Having the same base generator guarantees that the other
3211 : // iterator is of the same type and we can downcast.
3212 : GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
3213 : << "The program attempted to compare iterators "
3214 : << "from different generators." << std::endl;
3215 : const Iterator* typed_other =
3216 : CheckedDowncastToActualType<const Iterator>(&other);
3217 : // We must report iterators equal if they both point beyond their
3218 : // respective ranges. That can happen in a variety of fashions,
3219 : // so we have to consult AtEnd().
3220 : return (AtEnd() && typed_other->AtEnd()) ||
3221 : (
3222 : current1_ == typed_other->current1_ &&
3223 : current2_ == typed_other->current2_);
3224 : }
3225 :
3226 : private:
3227 : Iterator(const Iterator& other)
3228 : : base_(other.base_),
3229 : begin1_(other.begin1_),
3230 : end1_(other.end1_),
3231 : current1_(other.current1_),
3232 : begin2_(other.begin2_),
3233 : end2_(other.end2_),
3234 : current2_(other.current2_) {
3235 : ComputeCurrentValue();
3236 : }
3237 :
3238 : void ComputeCurrentValue() {
3239 : if (!AtEnd())
3240 : current_value_ = ParamType(*current1_, *current2_);
3241 : }
3242 : bool AtEnd() const {
3243 : // We must report iterator past the end of the range when either of the
3244 : // component iterators has reached the end of its range.
3245 : return
3246 : current1_ == end1_ ||
3247 : current2_ == end2_;
3248 : }
3249 :
3250 : // No implementation - assignment is unsupported.
3251 : void operator=(const Iterator& other);
3252 :
3253 : const ParamGeneratorInterface<ParamType>* const base_;
3254 : // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
3255 : // current[i]_ is the actual traversing iterator.
3256 : const typename ParamGenerator<T1>::iterator begin1_;
3257 : const typename ParamGenerator<T1>::iterator end1_;
3258 : typename ParamGenerator<T1>::iterator current1_;
3259 : const typename ParamGenerator<T2>::iterator begin2_;
3260 : const typename ParamGenerator<T2>::iterator end2_;
3261 : typename ParamGenerator<T2>::iterator current2_;
3262 : ParamType current_value_;
3263 : }; // class CartesianProductGenerator2::Iterator
3264 :
3265 : // No implementation - assignment is unsupported.
3266 : void operator=(const CartesianProductGenerator2& other);
3267 :
3268 : const ParamGenerator<T1> g1_;
3269 : const ParamGenerator<T2> g2_;
3270 : }; // class CartesianProductGenerator2
3271 :
3272 :
3273 : template <typename T1, typename T2, typename T3>
3274 : class CartesianProductGenerator3
3275 : : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3> > {
3276 : public:
3277 : typedef ::std::tr1::tuple<T1, T2, T3> ParamType;
3278 :
3279 : CartesianProductGenerator3(const ParamGenerator<T1>& g1,
3280 : const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3)
3281 : : g1_(g1), g2_(g2), g3_(g3) {}
3282 : virtual ~CartesianProductGenerator3() {}
3283 :
3284 : virtual ParamIteratorInterface<ParamType>* Begin() const {
3285 : return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
3286 : g3_.begin());
3287 : }
3288 : virtual ParamIteratorInterface<ParamType>* End() const {
3289 : return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end());
3290 : }
3291 :
3292 : private:
3293 : class Iterator : public ParamIteratorInterface<ParamType> {
3294 : public:
3295 : Iterator(const ParamGeneratorInterface<ParamType>* base,
3296 : const ParamGenerator<T1>& g1,
3297 : const typename ParamGenerator<T1>::iterator& current1,
3298 : const ParamGenerator<T2>& g2,
3299 : const typename ParamGenerator<T2>::iterator& current2,
3300 : const ParamGenerator<T3>& g3,
3301 : const typename ParamGenerator<T3>::iterator& current3)
3302 : : base_(base),
3303 : begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
3304 : begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
3305 : begin3_(g3.begin()), end3_(g3.end()), current3_(current3) {
3306 : ComputeCurrentValue();
3307 : }
3308 : virtual ~Iterator() {}
3309 :
3310 : virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
3311 : return base_;
3312 : }
3313 : // Advance should not be called on beyond-of-range iterators
3314 : // so no component iterators must be beyond end of range, either.
3315 : virtual void Advance() {
3316 : assert(!AtEnd());
3317 : ++current3_;
3318 : if (current3_ == end3_) {
3319 : current3_ = begin3_;
3320 : ++current2_;
3321 : }
3322 : if (current2_ == end2_) {
3323 : current2_ = begin2_;
3324 : ++current1_;
3325 : }
3326 : ComputeCurrentValue();
3327 : }
3328 : virtual ParamIteratorInterface<ParamType>* Clone() const {
3329 : return new Iterator(*this);
3330 : }
3331 : virtual const ParamType* Current() const { return ¤t_value_; }
3332 : virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
3333 : // Having the same base generator guarantees that the other
3334 : // iterator is of the same type and we can downcast.
3335 : GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
3336 : << "The program attempted to compare iterators "
3337 : << "from different generators." << std::endl;
3338 : const Iterator* typed_other =
3339 : CheckedDowncastToActualType<const Iterator>(&other);
3340 : // We must report iterators equal if they both point beyond their
3341 : // respective ranges. That can happen in a variety of fashions,
3342 : // so we have to consult AtEnd().
3343 : return (AtEnd() && typed_other->AtEnd()) ||
3344 : (
3345 : current1_ == typed_other->current1_ &&
3346 : current2_ == typed_other->current2_ &&
3347 : current3_ == typed_other->current3_);
3348 : }
3349 :
3350 : private:
3351 : Iterator(const Iterator& other)
3352 : : base_(other.base_),
3353 : begin1_(other.begin1_),
3354 : end1_(other.end1_),
3355 : current1_(other.current1_),
3356 : begin2_(other.begin2_),
3357 : end2_(other.end2_),
3358 : current2_(other.current2_),
3359 : begin3_(other.begin3_),
3360 : end3_(other.end3_),
3361 : current3_(other.current3_) {
3362 : ComputeCurrentValue();
3363 : }
3364 :
3365 : void ComputeCurrentValue() {
3366 : if (!AtEnd())
3367 : current_value_ = ParamType(*current1_, *current2_, *current3_);
3368 : }
3369 : bool AtEnd() const {
3370 : // We must report iterator past the end of the range when either of the
3371 : // component iterators has reached the end of its range.
3372 : return
3373 : current1_ == end1_ ||
3374 : current2_ == end2_ ||
3375 : current3_ == end3_;
3376 : }
3377 :
3378 : // No implementation - assignment is unsupported.
3379 : void operator=(const Iterator& other);
3380 :
3381 : const ParamGeneratorInterface<ParamType>* const base_;
3382 : // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
3383 : // current[i]_ is the actual traversing iterator.
3384 : const typename ParamGenerator<T1>::iterator begin1_;
3385 : const typename ParamGenerator<T1>::iterator end1_;
3386 : typename ParamGenerator<T1>::iterator current1_;
3387 : const typename ParamGenerator<T2>::iterator begin2_;
3388 : const typename ParamGenerator<T2>::iterator end2_;
3389 : typename ParamGenerator<T2>::iterator current2_;
3390 : const typename ParamGenerator<T3>::iterator begin3_;
3391 : const typename ParamGenerator<T3>::iterator end3_;
3392 : typename ParamGenerator<T3>::iterator current3_;
3393 : ParamType current_value_;
3394 : }; // class CartesianProductGenerator3::Iterator
3395 :
3396 : // No implementation - assignment is unsupported.
3397 : void operator=(const CartesianProductGenerator3& other);
3398 :
3399 : const ParamGenerator<T1> g1_;
3400 : const ParamGenerator<T2> g2_;
3401 : const ParamGenerator<T3> g3_;
3402 : }; // class CartesianProductGenerator3
3403 :
3404 :
3405 : template <typename T1, typename T2, typename T3, typename T4>
3406 : class CartesianProductGenerator4
3407 : : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4> > {
3408 : public:
3409 : typedef ::std::tr1::tuple<T1, T2, T3, T4> ParamType;
3410 :
3411 : CartesianProductGenerator4(const ParamGenerator<T1>& g1,
3412 : const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
3413 : const ParamGenerator<T4>& g4)
3414 : : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
3415 : virtual ~CartesianProductGenerator4() {}
3416 :
3417 : virtual ParamIteratorInterface<ParamType>* Begin() const {
3418 : return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
3419 : g3_.begin(), g4_, g4_.begin());
3420 : }
3421 : virtual ParamIteratorInterface<ParamType>* End() const {
3422 : return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
3423 : g4_, g4_.end());
3424 : }
3425 :
3426 : private:
3427 : class Iterator : public ParamIteratorInterface<ParamType> {
3428 : public:
3429 : Iterator(const ParamGeneratorInterface<ParamType>* base,
3430 : const ParamGenerator<T1>& g1,
3431 : const typename ParamGenerator<T1>::iterator& current1,
3432 : const ParamGenerator<T2>& g2,
3433 : const typename ParamGenerator<T2>::iterator& current2,
3434 : const ParamGenerator<T3>& g3,
3435 : const typename ParamGenerator<T3>::iterator& current3,
3436 : const ParamGenerator<T4>& g4,
3437 : const typename ParamGenerator<T4>::iterator& current4)
3438 : : base_(base),
3439 : begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
3440 : begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
3441 : begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
3442 : begin4_(g4.begin()), end4_(g4.end()), current4_(current4) {
3443 : ComputeCurrentValue();
3444 : }
3445 : virtual ~Iterator() {}
3446 :
3447 : virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
3448 : return base_;
3449 : }
3450 : // Advance should not be called on beyond-of-range iterators
3451 : // so no component iterators must be beyond end of range, either.
3452 : virtual void Advance() {
3453 : assert(!AtEnd());
3454 : ++current4_;
3455 : if (current4_ == end4_) {
3456 : current4_ = begin4_;
3457 : ++current3_;
3458 : }
3459 : if (current3_ == end3_) {
3460 : current3_ = begin3_;
3461 : ++current2_;
3462 : }
3463 : if (current2_ == end2_) {
3464 : current2_ = begin2_;
3465 : ++current1_;
3466 : }
3467 : ComputeCurrentValue();
3468 : }
3469 : virtual ParamIteratorInterface<ParamType>* Clone() const {
3470 : return new Iterator(*this);
3471 : }
3472 : virtual const ParamType* Current() const { return ¤t_value_; }
3473 : virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
3474 : // Having the same base generator guarantees that the other
3475 : // iterator is of the same type and we can downcast.
3476 : GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
3477 : << "The program attempted to compare iterators "
3478 : << "from different generators." << std::endl;
3479 : const Iterator* typed_other =
3480 : CheckedDowncastToActualType<const Iterator>(&other);
3481 : // We must report iterators equal if they both point beyond their
3482 : // respective ranges. That can happen in a variety of fashions,
3483 : // so we have to consult AtEnd().
3484 : return (AtEnd() && typed_other->AtEnd()) ||
3485 : (
3486 : current1_ == typed_other->current1_ &&
3487 : current2_ == typed_other->current2_ &&
3488 : current3_ == typed_other->current3_ &&
3489 : current4_ == typed_other->current4_);
3490 : }
3491 :
3492 : private:
3493 : Iterator(const Iterator& other)
3494 : : base_(other.base_),
3495 : begin1_(other.begin1_),
3496 : end1_(other.end1_),
3497 : current1_(other.current1_),
3498 : begin2_(other.begin2_),
3499 : end2_(other.end2_),
3500 : current2_(other.current2_),
3501 : begin3_(other.begin3_),
3502 : end3_(other.end3_),
3503 : current3_(other.current3_),
3504 : begin4_(other.begin4_),
3505 : end4_(other.end4_),
3506 : current4_(other.current4_) {
3507 : ComputeCurrentValue();
3508 : }
3509 :
3510 : void ComputeCurrentValue() {
3511 : if (!AtEnd())
3512 : current_value_ = ParamType(*current1_, *current2_, *current3_,
3513 : *current4_);
3514 : }
3515 : bool AtEnd() const {
3516 : // We must report iterator past the end of the range when either of the
3517 : // component iterators has reached the end of its range.
3518 : return
3519 : current1_ == end1_ ||
3520 : current2_ == end2_ ||
3521 : current3_ == end3_ ||
3522 : current4_ == end4_;
3523 : }
3524 :
3525 : // No implementation - assignment is unsupported.
3526 : void operator=(const Iterator& other);
3527 :
3528 : const ParamGeneratorInterface<ParamType>* const base_;
3529 : // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
3530 : // current[i]_ is the actual traversing iterator.
3531 : const typename ParamGenerator<T1>::iterator begin1_;
3532 : const typename ParamGenerator<T1>::iterator end1_;
3533 : typename ParamGenerator<T1>::iterator current1_;
3534 : const typename ParamGenerator<T2>::iterator begin2_;
3535 : const typename ParamGenerator<T2>::iterator end2_;
3536 : typename ParamGenerator<T2>::iterator current2_;
3537 : const typename ParamGenerator<T3>::iterator begin3_;
3538 : const typename ParamGenerator<T3>::iterator end3_;
3539 : typename ParamGenerator<T3>::iterator current3_;
3540 : const typename ParamGenerator<T4>::iterator begin4_;
3541 : const typename ParamGenerator<T4>::iterator end4_;
3542 : typename ParamGenerator<T4>::iterator current4_;
3543 : ParamType current_value_;
3544 : }; // class CartesianProductGenerator4::Iterator
3545 :
3546 : // No implementation - assignment is unsupported.
3547 : void operator=(const CartesianProductGenerator4& other);
3548 :
3549 : const ParamGenerator<T1> g1_;
3550 : const ParamGenerator<T2> g2_;
3551 : const ParamGenerator<T3> g3_;
3552 : const ParamGenerator<T4> g4_;
3553 : }; // class CartesianProductGenerator4
3554 :
3555 :
3556 : template <typename T1, typename T2, typename T3, typename T4, typename T5>
3557 : class CartesianProductGenerator5
3558 : : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5> > {
3559 : public:
3560 : typedef ::std::tr1::tuple<T1, T2, T3, T4, T5> ParamType;
3561 :
3562 : CartesianProductGenerator5(const ParamGenerator<T1>& g1,
3563 : const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
3564 : const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5)
3565 : : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
3566 : virtual ~CartesianProductGenerator5() {}
3567 :
3568 : virtual ParamIteratorInterface<ParamType>* Begin() const {
3569 : return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
3570 : g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin());
3571 : }
3572 : virtual ParamIteratorInterface<ParamType>* End() const {
3573 : return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
3574 : g4_, g4_.end(), g5_, g5_.end());
3575 : }
3576 :
3577 : private:
3578 : class Iterator : public ParamIteratorInterface<ParamType> {
3579 : public:
3580 : Iterator(const ParamGeneratorInterface<ParamType>* base,
3581 : const ParamGenerator<T1>& g1,
3582 : const typename ParamGenerator<T1>::iterator& current1,
3583 : const ParamGenerator<T2>& g2,
3584 : const typename ParamGenerator<T2>::iterator& current2,
3585 : const ParamGenerator<T3>& g3,
3586 : const typename ParamGenerator<T3>::iterator& current3,
3587 : const ParamGenerator<T4>& g4,
3588 : const typename ParamGenerator<T4>::iterator& current4,
3589 : const ParamGenerator<T5>& g5,
3590 : const typename ParamGenerator<T5>::iterator& current5)
3591 : : base_(base),
3592 : begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
3593 : begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
3594 : begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
3595 : begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
3596 : begin5_(g5.begin()), end5_(g5.end()), current5_(current5) {
3597 : ComputeCurrentValue();
3598 : }
3599 : virtual ~Iterator() {}
3600 :
3601 : virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
3602 : return base_;
3603 : }
3604 : // Advance should not be called on beyond-of-range iterators
3605 : // so no component iterators must be beyond end of range, either.
3606 : virtual void Advance() {
3607 : assert(!AtEnd());
3608 : ++current5_;
3609 : if (current5_ == end5_) {
3610 : current5_ = begin5_;
3611 : ++current4_;
3612 : }
3613 : if (current4_ == end4_) {
3614 : current4_ = begin4_;
3615 : ++current3_;
3616 : }
3617 : if (current3_ == end3_) {
3618 : current3_ = begin3_;
3619 : ++current2_;
3620 : }
3621 : if (current2_ == end2_) {
3622 : current2_ = begin2_;
3623 : ++current1_;
3624 : }
3625 : ComputeCurrentValue();
3626 : }
3627 : virtual ParamIteratorInterface<ParamType>* Clone() const {
3628 : return new Iterator(*this);
3629 : }
3630 : virtual const ParamType* Current() const { return ¤t_value_; }
3631 : virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
3632 : // Having the same base generator guarantees that the other
3633 : // iterator is of the same type and we can downcast.
3634 : GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
3635 : << "The program attempted to compare iterators "
3636 : << "from different generators." << std::endl;
3637 : const Iterator* typed_other =
3638 : CheckedDowncastToActualType<const Iterator>(&other);
3639 : // We must report iterators equal if they both point beyond their
3640 : // respective ranges. That can happen in a variety of fashions,
3641 : // so we have to consult AtEnd().
3642 : return (AtEnd() && typed_other->AtEnd()) ||
3643 : (
3644 : current1_ == typed_other->current1_ &&
3645 : current2_ == typed_other->current2_ &&
3646 : current3_ == typed_other->current3_ &&
3647 : current4_ == typed_other->current4_ &&
3648 : current5_ == typed_other->current5_);
3649 : }
3650 :
3651 : private:
3652 : Iterator(const Iterator& other)
3653 : : base_(other.base_),
3654 : begin1_(other.begin1_),
3655 : end1_(other.end1_),
3656 : current1_(other.current1_),
3657 : begin2_(other.begin2_),
3658 : end2_(other.end2_),
3659 : current2_(other.current2_),
3660 : begin3_(other.begin3_),
3661 : end3_(other.end3_),
3662 : current3_(other.current3_),
3663 : begin4_(other.begin4_),
3664 : end4_(other.end4_),
3665 : current4_(other.current4_),
3666 : begin5_(other.begin5_),
3667 : end5_(other.end5_),
3668 : current5_(other.current5_) {
3669 : ComputeCurrentValue();
3670 : }
3671 :
3672 : void ComputeCurrentValue() {
3673 : if (!AtEnd())
3674 : current_value_ = ParamType(*current1_, *current2_, *current3_,
3675 : *current4_, *current5_);
3676 : }
3677 : bool AtEnd() const {
3678 : // We must report iterator past the end of the range when either of the
3679 : // component iterators has reached the end of its range.
3680 : return
3681 : current1_ == end1_ ||
3682 : current2_ == end2_ ||
3683 : current3_ == end3_ ||
3684 : current4_ == end4_ ||
3685 : current5_ == end5_;
3686 : }
3687 :
3688 : // No implementation - assignment is unsupported.
3689 : void operator=(const Iterator& other);
3690 :
3691 : const ParamGeneratorInterface<ParamType>* const base_;
3692 : // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
3693 : // current[i]_ is the actual traversing iterator.
3694 : const typename ParamGenerator<T1>::iterator begin1_;
3695 : const typename ParamGenerator<T1>::iterator end1_;
3696 : typename ParamGenerator<T1>::iterator current1_;
3697 : const typename ParamGenerator<T2>::iterator begin2_;
3698 : const typename ParamGenerator<T2>::iterator end2_;
3699 : typename ParamGenerator<T2>::iterator current2_;
3700 : const typename ParamGenerator<T3>::iterator begin3_;
3701 : const typename ParamGenerator<T3>::iterator end3_;
3702 : typename ParamGenerator<T3>::iterator current3_;
3703 : const typename ParamGenerator<T4>::iterator begin4_;
3704 : const typename ParamGenerator<T4>::iterator end4_;
3705 : typename ParamGenerator<T4>::iterator current4_;
3706 : const typename ParamGenerator<T5>::iterator begin5_;
3707 : const typename ParamGenerator<T5>::iterator end5_;
3708 : typename ParamGenerator<T5>::iterator current5_;
3709 : ParamType current_value_;
3710 : }; // class CartesianProductGenerator5::Iterator
3711 :
3712 : // No implementation - assignment is unsupported.
3713 : void operator=(const CartesianProductGenerator5& other);
3714 :
3715 : const ParamGenerator<T1> g1_;
3716 : const ParamGenerator<T2> g2_;
3717 : const ParamGenerator<T3> g3_;
3718 : const ParamGenerator<T4> g4_;
3719 : const ParamGenerator<T5> g5_;
3720 : }; // class CartesianProductGenerator5
3721 :
3722 :
3723 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
3724 : typename T6>
3725 : class CartesianProductGenerator6
3726 : : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5,
3727 : T6> > {
3728 : public:
3729 : typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> ParamType;
3730 :
3731 : CartesianProductGenerator6(const ParamGenerator<T1>& g1,
3732 : const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
3733 : const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
3734 : const ParamGenerator<T6>& g6)
3735 : : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
3736 : virtual ~CartesianProductGenerator6() {}
3737 :
3738 : virtual ParamIteratorInterface<ParamType>* Begin() const {
3739 : return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
3740 : g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin());
3741 : }
3742 : virtual ParamIteratorInterface<ParamType>* End() const {
3743 : return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
3744 : g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end());
3745 : }
3746 :
3747 : private:
3748 : class Iterator : public ParamIteratorInterface<ParamType> {
3749 : public:
3750 : Iterator(const ParamGeneratorInterface<ParamType>* base,
3751 : const ParamGenerator<T1>& g1,
3752 : const typename ParamGenerator<T1>::iterator& current1,
3753 : const ParamGenerator<T2>& g2,
3754 : const typename ParamGenerator<T2>::iterator& current2,
3755 : const ParamGenerator<T3>& g3,
3756 : const typename ParamGenerator<T3>::iterator& current3,
3757 : const ParamGenerator<T4>& g4,
3758 : const typename ParamGenerator<T4>::iterator& current4,
3759 : const ParamGenerator<T5>& g5,
3760 : const typename ParamGenerator<T5>::iterator& current5,
3761 : const ParamGenerator<T6>& g6,
3762 : const typename ParamGenerator<T6>::iterator& current6)
3763 : : base_(base),
3764 : begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
3765 : begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
3766 : begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
3767 : begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
3768 : begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
3769 : begin6_(g6.begin()), end6_(g6.end()), current6_(current6) {
3770 : ComputeCurrentValue();
3771 : }
3772 : virtual ~Iterator() {}
3773 :
3774 : virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
3775 : return base_;
3776 : }
3777 : // Advance should not be called on beyond-of-range iterators
3778 : // so no component iterators must be beyond end of range, either.
3779 : virtual void Advance() {
3780 : assert(!AtEnd());
3781 : ++current6_;
3782 : if (current6_ == end6_) {
3783 : current6_ = begin6_;
3784 : ++current5_;
3785 : }
3786 : if (current5_ == end5_) {
3787 : current5_ = begin5_;
3788 : ++current4_;
3789 : }
3790 : if (current4_ == end4_) {
3791 : current4_ = begin4_;
3792 : ++current3_;
3793 : }
3794 : if (current3_ == end3_) {
3795 : current3_ = begin3_;
3796 : ++current2_;
3797 : }
3798 : if (current2_ == end2_) {
3799 : current2_ = begin2_;
3800 : ++current1_;
3801 : }
3802 : ComputeCurrentValue();
3803 : }
3804 : virtual ParamIteratorInterface<ParamType>* Clone() const {
3805 : return new Iterator(*this);
3806 : }
3807 : virtual const ParamType* Current() const { return ¤t_value_; }
3808 : virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
3809 : // Having the same base generator guarantees that the other
3810 : // iterator is of the same type and we can downcast.
3811 : GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
3812 : << "The program attempted to compare iterators "
3813 : << "from different generators." << std::endl;
3814 : const Iterator* typed_other =
3815 : CheckedDowncastToActualType<const Iterator>(&other);
3816 : // We must report iterators equal if they both point beyond their
3817 : // respective ranges. That can happen in a variety of fashions,
3818 : // so we have to consult AtEnd().
3819 : return (AtEnd() && typed_other->AtEnd()) ||
3820 : (
3821 : current1_ == typed_other->current1_ &&
3822 : current2_ == typed_other->current2_ &&
3823 : current3_ == typed_other->current3_ &&
3824 : current4_ == typed_other->current4_ &&
3825 : current5_ == typed_other->current5_ &&
3826 : current6_ == typed_other->current6_);
3827 : }
3828 :
3829 : private:
3830 : Iterator(const Iterator& other)
3831 : : base_(other.base_),
3832 : begin1_(other.begin1_),
3833 : end1_(other.end1_),
3834 : current1_(other.current1_),
3835 : begin2_(other.begin2_),
3836 : end2_(other.end2_),
3837 : current2_(other.current2_),
3838 : begin3_(other.begin3_),
3839 : end3_(other.end3_),
3840 : current3_(other.current3_),
3841 : begin4_(other.begin4_),
3842 : end4_(other.end4_),
3843 : current4_(other.current4_),
3844 : begin5_(other.begin5_),
3845 : end5_(other.end5_),
3846 : current5_(other.current5_),
3847 : begin6_(other.begin6_),
3848 : end6_(other.end6_),
3849 : current6_(other.current6_) {
3850 : ComputeCurrentValue();
3851 : }
3852 :
3853 : void ComputeCurrentValue() {
3854 : if (!AtEnd())
3855 : current_value_ = ParamType(*current1_, *current2_, *current3_,
3856 : *current4_, *current5_, *current6_);
3857 : }
3858 : bool AtEnd() const {
3859 : // We must report iterator past the end of the range when either of the
3860 : // component iterators has reached the end of its range.
3861 : return
3862 : current1_ == end1_ ||
3863 : current2_ == end2_ ||
3864 : current3_ == end3_ ||
3865 : current4_ == end4_ ||
3866 : current5_ == end5_ ||
3867 : current6_ == end6_;
3868 : }
3869 :
3870 : // No implementation - assignment is unsupported.
3871 : void operator=(const Iterator& other);
3872 :
3873 : const ParamGeneratorInterface<ParamType>* const base_;
3874 : // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
3875 : // current[i]_ is the actual traversing iterator.
3876 : const typename ParamGenerator<T1>::iterator begin1_;
3877 : const typename ParamGenerator<T1>::iterator end1_;
3878 : typename ParamGenerator<T1>::iterator current1_;
3879 : const typename ParamGenerator<T2>::iterator begin2_;
3880 : const typename ParamGenerator<T2>::iterator end2_;
3881 : typename ParamGenerator<T2>::iterator current2_;
3882 : const typename ParamGenerator<T3>::iterator begin3_;
3883 : const typename ParamGenerator<T3>::iterator end3_;
3884 : typename ParamGenerator<T3>::iterator current3_;
3885 : const typename ParamGenerator<T4>::iterator begin4_;
3886 : const typename ParamGenerator<T4>::iterator end4_;
3887 : typename ParamGenerator<T4>::iterator current4_;
3888 : const typename ParamGenerator<T5>::iterator begin5_;
3889 : const typename ParamGenerator<T5>::iterator end5_;
3890 : typename ParamGenerator<T5>::iterator current5_;
3891 : const typename ParamGenerator<T6>::iterator begin6_;
3892 : const typename ParamGenerator<T6>::iterator end6_;
3893 : typename ParamGenerator<T6>::iterator current6_;
3894 : ParamType current_value_;
3895 : }; // class CartesianProductGenerator6::Iterator
3896 :
3897 : // No implementation - assignment is unsupported.
3898 : void operator=(const CartesianProductGenerator6& other);
3899 :
3900 : const ParamGenerator<T1> g1_;
3901 : const ParamGenerator<T2> g2_;
3902 : const ParamGenerator<T3> g3_;
3903 : const ParamGenerator<T4> g4_;
3904 : const ParamGenerator<T5> g5_;
3905 : const ParamGenerator<T6> g6_;
3906 : }; // class CartesianProductGenerator6
3907 :
3908 :
3909 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
3910 : typename T6, typename T7>
3911 : class CartesianProductGenerator7
3912 : : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
3913 : T7> > {
3914 : public:
3915 : typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7> ParamType;
3916 :
3917 : CartesianProductGenerator7(const ParamGenerator<T1>& g1,
3918 : const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
3919 : const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
3920 : const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7)
3921 : : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
3922 : virtual ~CartesianProductGenerator7() {}
3923 :
3924 : virtual ParamIteratorInterface<ParamType>* Begin() const {
3925 : return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
3926 : g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
3927 : g7_.begin());
3928 : }
3929 : virtual ParamIteratorInterface<ParamType>* End() const {
3930 : return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
3931 : g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end());
3932 : }
3933 :
3934 : private:
3935 : class Iterator : public ParamIteratorInterface<ParamType> {
3936 : public:
3937 : Iterator(const ParamGeneratorInterface<ParamType>* base,
3938 : const ParamGenerator<T1>& g1,
3939 : const typename ParamGenerator<T1>::iterator& current1,
3940 : const ParamGenerator<T2>& g2,
3941 : const typename ParamGenerator<T2>::iterator& current2,
3942 : const ParamGenerator<T3>& g3,
3943 : const typename ParamGenerator<T3>::iterator& current3,
3944 : const ParamGenerator<T4>& g4,
3945 : const typename ParamGenerator<T4>::iterator& current4,
3946 : const ParamGenerator<T5>& g5,
3947 : const typename ParamGenerator<T5>::iterator& current5,
3948 : const ParamGenerator<T6>& g6,
3949 : const typename ParamGenerator<T6>::iterator& current6,
3950 : const ParamGenerator<T7>& g7,
3951 : const typename ParamGenerator<T7>::iterator& current7)
3952 : : base_(base),
3953 : begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
3954 : begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
3955 : begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
3956 : begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
3957 : begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
3958 : begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
3959 : begin7_(g7.begin()), end7_(g7.end()), current7_(current7) {
3960 : ComputeCurrentValue();
3961 : }
3962 : virtual ~Iterator() {}
3963 :
3964 : virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
3965 : return base_;
3966 : }
3967 : // Advance should not be called on beyond-of-range iterators
3968 : // so no component iterators must be beyond end of range, either.
3969 : virtual void Advance() {
3970 : assert(!AtEnd());
3971 : ++current7_;
3972 : if (current7_ == end7_) {
3973 : current7_ = begin7_;
3974 : ++current6_;
3975 : }
3976 : if (current6_ == end6_) {
3977 : current6_ = begin6_;
3978 : ++current5_;
3979 : }
3980 : if (current5_ == end5_) {
3981 : current5_ = begin5_;
3982 : ++current4_;
3983 : }
3984 : if (current4_ == end4_) {
3985 : current4_ = begin4_;
3986 : ++current3_;
3987 : }
3988 : if (current3_ == end3_) {
3989 : current3_ = begin3_;
3990 : ++current2_;
3991 : }
3992 : if (current2_ == end2_) {
3993 : current2_ = begin2_;
3994 : ++current1_;
3995 : }
3996 : ComputeCurrentValue();
3997 : }
3998 : virtual ParamIteratorInterface<ParamType>* Clone() const {
3999 : return new Iterator(*this);
4000 : }
4001 : virtual const ParamType* Current() const { return ¤t_value_; }
4002 : virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
4003 : // Having the same base generator guarantees that the other
4004 : // iterator is of the same type and we can downcast.
4005 : GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
4006 : << "The program attempted to compare iterators "
4007 : << "from different generators." << std::endl;
4008 : const Iterator* typed_other =
4009 : CheckedDowncastToActualType<const Iterator>(&other);
4010 : // We must report iterators equal if they both point beyond their
4011 : // respective ranges. That can happen in a variety of fashions,
4012 : // so we have to consult AtEnd().
4013 : return (AtEnd() && typed_other->AtEnd()) ||
4014 : (
4015 : current1_ == typed_other->current1_ &&
4016 : current2_ == typed_other->current2_ &&
4017 : current3_ == typed_other->current3_ &&
4018 : current4_ == typed_other->current4_ &&
4019 : current5_ == typed_other->current5_ &&
4020 : current6_ == typed_other->current6_ &&
4021 : current7_ == typed_other->current7_);
4022 : }
4023 :
4024 : private:
4025 : Iterator(const Iterator& other)
4026 : : base_(other.base_),
4027 : begin1_(other.begin1_),
4028 : end1_(other.end1_),
4029 : current1_(other.current1_),
4030 : begin2_(other.begin2_),
4031 : end2_(other.end2_),
4032 : current2_(other.current2_),
4033 : begin3_(other.begin3_),
4034 : end3_(other.end3_),
4035 : current3_(other.current3_),
4036 : begin4_(other.begin4_),
4037 : end4_(other.end4_),
4038 : current4_(other.current4_),
4039 : begin5_(other.begin5_),
4040 : end5_(other.end5_),
4041 : current5_(other.current5_),
4042 : begin6_(other.begin6_),
4043 : end6_(other.end6_),
4044 : current6_(other.current6_),
4045 : begin7_(other.begin7_),
4046 : end7_(other.end7_),
4047 : current7_(other.current7_) {
4048 : ComputeCurrentValue();
4049 : }
4050 :
4051 : void ComputeCurrentValue() {
4052 : if (!AtEnd())
4053 : current_value_ = ParamType(*current1_, *current2_, *current3_,
4054 : *current4_, *current5_, *current6_, *current7_);
4055 : }
4056 : bool AtEnd() const {
4057 : // We must report iterator past the end of the range when either of the
4058 : // component iterators has reached the end of its range.
4059 : return
4060 : current1_ == end1_ ||
4061 : current2_ == end2_ ||
4062 : current3_ == end3_ ||
4063 : current4_ == end4_ ||
4064 : current5_ == end5_ ||
4065 : current6_ == end6_ ||
4066 : current7_ == end7_;
4067 : }
4068 :
4069 : // No implementation - assignment is unsupported.
4070 : void operator=(const Iterator& other);
4071 :
4072 : const ParamGeneratorInterface<ParamType>* const base_;
4073 : // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
4074 : // current[i]_ is the actual traversing iterator.
4075 : const typename ParamGenerator<T1>::iterator begin1_;
4076 : const typename ParamGenerator<T1>::iterator end1_;
4077 : typename ParamGenerator<T1>::iterator current1_;
4078 : const typename ParamGenerator<T2>::iterator begin2_;
4079 : const typename ParamGenerator<T2>::iterator end2_;
4080 : typename ParamGenerator<T2>::iterator current2_;
4081 : const typename ParamGenerator<T3>::iterator begin3_;
4082 : const typename ParamGenerator<T3>::iterator end3_;
4083 : typename ParamGenerator<T3>::iterator current3_;
4084 : const typename ParamGenerator<T4>::iterator begin4_;
4085 : const typename ParamGenerator<T4>::iterator end4_;
4086 : typename ParamGenerator<T4>::iterator current4_;
4087 : const typename ParamGenerator<T5>::iterator begin5_;
4088 : const typename ParamGenerator<T5>::iterator end5_;
4089 : typename ParamGenerator<T5>::iterator current5_;
4090 : const typename ParamGenerator<T6>::iterator begin6_;
4091 : const typename ParamGenerator<T6>::iterator end6_;
4092 : typename ParamGenerator<T6>::iterator current6_;
4093 : const typename ParamGenerator<T7>::iterator begin7_;
4094 : const typename ParamGenerator<T7>::iterator end7_;
4095 : typename ParamGenerator<T7>::iterator current7_;
4096 : ParamType current_value_;
4097 : }; // class CartesianProductGenerator7::Iterator
4098 :
4099 : // No implementation - assignment is unsupported.
4100 : void operator=(const CartesianProductGenerator7& other);
4101 :
4102 : const ParamGenerator<T1> g1_;
4103 : const ParamGenerator<T2> g2_;
4104 : const ParamGenerator<T3> g3_;
4105 : const ParamGenerator<T4> g4_;
4106 : const ParamGenerator<T5> g5_;
4107 : const ParamGenerator<T6> g6_;
4108 : const ParamGenerator<T7> g7_;
4109 : }; // class CartesianProductGenerator7
4110 :
4111 :
4112 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
4113 : typename T6, typename T7, typename T8>
4114 : class CartesianProductGenerator8
4115 : : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
4116 : T7, T8> > {
4117 : public:
4118 : typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8> ParamType;
4119 :
4120 : CartesianProductGenerator8(const ParamGenerator<T1>& g1,
4121 : const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
4122 : const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
4123 : const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
4124 : const ParamGenerator<T8>& g8)
4125 : : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
4126 : g8_(g8) {}
4127 : virtual ~CartesianProductGenerator8() {}
4128 :
4129 : virtual ParamIteratorInterface<ParamType>* Begin() const {
4130 : return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
4131 : g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
4132 : g7_.begin(), g8_, g8_.begin());
4133 : }
4134 : virtual ParamIteratorInterface<ParamType>* End() const {
4135 : return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
4136 : g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
4137 : g8_.end());
4138 : }
4139 :
4140 : private:
4141 : class Iterator : public ParamIteratorInterface<ParamType> {
4142 : public:
4143 : Iterator(const ParamGeneratorInterface<ParamType>* base,
4144 : const ParamGenerator<T1>& g1,
4145 : const typename ParamGenerator<T1>::iterator& current1,
4146 : const ParamGenerator<T2>& g2,
4147 : const typename ParamGenerator<T2>::iterator& current2,
4148 : const ParamGenerator<T3>& g3,
4149 : const typename ParamGenerator<T3>::iterator& current3,
4150 : const ParamGenerator<T4>& g4,
4151 : const typename ParamGenerator<T4>::iterator& current4,
4152 : const ParamGenerator<T5>& g5,
4153 : const typename ParamGenerator<T5>::iterator& current5,
4154 : const ParamGenerator<T6>& g6,
4155 : const typename ParamGenerator<T6>::iterator& current6,
4156 : const ParamGenerator<T7>& g7,
4157 : const typename ParamGenerator<T7>::iterator& current7,
4158 : const ParamGenerator<T8>& g8,
4159 : const typename ParamGenerator<T8>::iterator& current8)
4160 : : base_(base),
4161 : begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
4162 : begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
4163 : begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
4164 : begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
4165 : begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
4166 : begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
4167 : begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
4168 : begin8_(g8.begin()), end8_(g8.end()), current8_(current8) {
4169 : ComputeCurrentValue();
4170 : }
4171 : virtual ~Iterator() {}
4172 :
4173 : virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
4174 : return base_;
4175 : }
4176 : // Advance should not be called on beyond-of-range iterators
4177 : // so no component iterators must be beyond end of range, either.
4178 : virtual void Advance() {
4179 : assert(!AtEnd());
4180 : ++current8_;
4181 : if (current8_ == end8_) {
4182 : current8_ = begin8_;
4183 : ++current7_;
4184 : }
4185 : if (current7_ == end7_) {
4186 : current7_ = begin7_;
4187 : ++current6_;
4188 : }
4189 : if (current6_ == end6_) {
4190 : current6_ = begin6_;
4191 : ++current5_;
4192 : }
4193 : if (current5_ == end5_) {
4194 : current5_ = begin5_;
4195 : ++current4_;
4196 : }
4197 : if (current4_ == end4_) {
4198 : current4_ = begin4_;
4199 : ++current3_;
4200 : }
4201 : if (current3_ == end3_) {
4202 : current3_ = begin3_;
4203 : ++current2_;
4204 : }
4205 : if (current2_ == end2_) {
4206 : current2_ = begin2_;
4207 : ++current1_;
4208 : }
4209 : ComputeCurrentValue();
4210 : }
4211 : virtual ParamIteratorInterface<ParamType>* Clone() const {
4212 : return new Iterator(*this);
4213 : }
4214 : virtual const ParamType* Current() const { return ¤t_value_; }
4215 : virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
4216 : // Having the same base generator guarantees that the other
4217 : // iterator is of the same type and we can downcast.
4218 : GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
4219 : << "The program attempted to compare iterators "
4220 : << "from different generators." << std::endl;
4221 : const Iterator* typed_other =
4222 : CheckedDowncastToActualType<const Iterator>(&other);
4223 : // We must report iterators equal if they both point beyond their
4224 : // respective ranges. That can happen in a variety of fashions,
4225 : // so we have to consult AtEnd().
4226 : return (AtEnd() && typed_other->AtEnd()) ||
4227 : (
4228 : current1_ == typed_other->current1_ &&
4229 : current2_ == typed_other->current2_ &&
4230 : current3_ == typed_other->current3_ &&
4231 : current4_ == typed_other->current4_ &&
4232 : current5_ == typed_other->current5_ &&
4233 : current6_ == typed_other->current6_ &&
4234 : current7_ == typed_other->current7_ &&
4235 : current8_ == typed_other->current8_);
4236 : }
4237 :
4238 : private:
4239 : Iterator(const Iterator& other)
4240 : : base_(other.base_),
4241 : begin1_(other.begin1_),
4242 : end1_(other.end1_),
4243 : current1_(other.current1_),
4244 : begin2_(other.begin2_),
4245 : end2_(other.end2_),
4246 : current2_(other.current2_),
4247 : begin3_(other.begin3_),
4248 : end3_(other.end3_),
4249 : current3_(other.current3_),
4250 : begin4_(other.begin4_),
4251 : end4_(other.end4_),
4252 : current4_(other.current4_),
4253 : begin5_(other.begin5_),
4254 : end5_(other.end5_),
4255 : current5_(other.current5_),
4256 : begin6_(other.begin6_),
4257 : end6_(other.end6_),
4258 : current6_(other.current6_),
4259 : begin7_(other.begin7_),
4260 : end7_(other.end7_),
4261 : current7_(other.current7_),
4262 : begin8_(other.begin8_),
4263 : end8_(other.end8_),
4264 : current8_(other.current8_) {
4265 : ComputeCurrentValue();
4266 : }
4267 :
4268 : void ComputeCurrentValue() {
4269 : if (!AtEnd())
4270 : current_value_ = ParamType(*current1_, *current2_, *current3_,
4271 : *current4_, *current5_, *current6_, *current7_, *current8_);
4272 : }
4273 : bool AtEnd() const {
4274 : // We must report iterator past the end of the range when either of the
4275 : // component iterators has reached the end of its range.
4276 : return
4277 : current1_ == end1_ ||
4278 : current2_ == end2_ ||
4279 : current3_ == end3_ ||
4280 : current4_ == end4_ ||
4281 : current5_ == end5_ ||
4282 : current6_ == end6_ ||
4283 : current7_ == end7_ ||
4284 : current8_ == end8_;
4285 : }
4286 :
4287 : // No implementation - assignment is unsupported.
4288 : void operator=(const Iterator& other);
4289 :
4290 : const ParamGeneratorInterface<ParamType>* const base_;
4291 : // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
4292 : // current[i]_ is the actual traversing iterator.
4293 : const typename ParamGenerator<T1>::iterator begin1_;
4294 : const typename ParamGenerator<T1>::iterator end1_;
4295 : typename ParamGenerator<T1>::iterator current1_;
4296 : const typename ParamGenerator<T2>::iterator begin2_;
4297 : const typename ParamGenerator<T2>::iterator end2_;
4298 : typename ParamGenerator<T2>::iterator current2_;
4299 : const typename ParamGenerator<T3>::iterator begin3_;
4300 : const typename ParamGenerator<T3>::iterator end3_;
4301 : typename ParamGenerator<T3>::iterator current3_;
4302 : const typename ParamGenerator<T4>::iterator begin4_;
4303 : const typename ParamGenerator<T4>::iterator end4_;
4304 : typename ParamGenerator<T4>::iterator current4_;
4305 : const typename ParamGenerator<T5>::iterator begin5_;
4306 : const typename ParamGenerator<T5>::iterator end5_;
4307 : typename ParamGenerator<T5>::iterator current5_;
4308 : const typename ParamGenerator<T6>::iterator begin6_;
4309 : const typename ParamGenerator<T6>::iterator end6_;
4310 : typename ParamGenerator<T6>::iterator current6_;
4311 : const typename ParamGenerator<T7>::iterator begin7_;
4312 : const typename ParamGenerator<T7>::iterator end7_;
4313 : typename ParamGenerator<T7>::iterator current7_;
4314 : const typename ParamGenerator<T8>::iterator begin8_;
4315 : const typename ParamGenerator<T8>::iterator end8_;
4316 : typename ParamGenerator<T8>::iterator current8_;
4317 : ParamType current_value_;
4318 : }; // class CartesianProductGenerator8::Iterator
4319 :
4320 : // No implementation - assignment is unsupported.
4321 : void operator=(const CartesianProductGenerator8& other);
4322 :
4323 : const ParamGenerator<T1> g1_;
4324 : const ParamGenerator<T2> g2_;
4325 : const ParamGenerator<T3> g3_;
4326 : const ParamGenerator<T4> g4_;
4327 : const ParamGenerator<T5> g5_;
4328 : const ParamGenerator<T6> g6_;
4329 : const ParamGenerator<T7> g7_;
4330 : const ParamGenerator<T8> g8_;
4331 : }; // class CartesianProductGenerator8
4332 :
4333 :
4334 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
4335 : typename T6, typename T7, typename T8, typename T9>
4336 : class CartesianProductGenerator9
4337 : : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
4338 : T7, T8, T9> > {
4339 : public:
4340 : typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> ParamType;
4341 :
4342 : CartesianProductGenerator9(const ParamGenerator<T1>& g1,
4343 : const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
4344 : const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
4345 : const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
4346 : const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9)
4347 : : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
4348 : g9_(g9) {}
4349 : virtual ~CartesianProductGenerator9() {}
4350 :
4351 : virtual ParamIteratorInterface<ParamType>* Begin() const {
4352 : return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
4353 : g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
4354 : g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin());
4355 : }
4356 : virtual ParamIteratorInterface<ParamType>* End() const {
4357 : return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
4358 : g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
4359 : g8_.end(), g9_, g9_.end());
4360 : }
4361 :
4362 : private:
4363 : class Iterator : public ParamIteratorInterface<ParamType> {
4364 : public:
4365 : Iterator(const ParamGeneratorInterface<ParamType>* base,
4366 : const ParamGenerator<T1>& g1,
4367 : const typename ParamGenerator<T1>::iterator& current1,
4368 : const ParamGenerator<T2>& g2,
4369 : const typename ParamGenerator<T2>::iterator& current2,
4370 : const ParamGenerator<T3>& g3,
4371 : const typename ParamGenerator<T3>::iterator& current3,
4372 : const ParamGenerator<T4>& g4,
4373 : const typename ParamGenerator<T4>::iterator& current4,
4374 : const ParamGenerator<T5>& g5,
4375 : const typename ParamGenerator<T5>::iterator& current5,
4376 : const ParamGenerator<T6>& g6,
4377 : const typename ParamGenerator<T6>::iterator& current6,
4378 : const ParamGenerator<T7>& g7,
4379 : const typename ParamGenerator<T7>::iterator& current7,
4380 : const ParamGenerator<T8>& g8,
4381 : const typename ParamGenerator<T8>::iterator& current8,
4382 : const ParamGenerator<T9>& g9,
4383 : const typename ParamGenerator<T9>::iterator& current9)
4384 : : base_(base),
4385 : begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
4386 : begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
4387 : begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
4388 : begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
4389 : begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
4390 : begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
4391 : begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
4392 : begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
4393 : begin9_(g9.begin()), end9_(g9.end()), current9_(current9) {
4394 : ComputeCurrentValue();
4395 : }
4396 : virtual ~Iterator() {}
4397 :
4398 : virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
4399 : return base_;
4400 : }
4401 : // Advance should not be called on beyond-of-range iterators
4402 : // so no component iterators must be beyond end of range, either.
4403 : virtual void Advance() {
4404 : assert(!AtEnd());
4405 : ++current9_;
4406 : if (current9_ == end9_) {
4407 : current9_ = begin9_;
4408 : ++current8_;
4409 : }
4410 : if (current8_ == end8_) {
4411 : current8_ = begin8_;
4412 : ++current7_;
4413 : }
4414 : if (current7_ == end7_) {
4415 : current7_ = begin7_;
4416 : ++current6_;
4417 : }
4418 : if (current6_ == end6_) {
4419 : current6_ = begin6_;
4420 : ++current5_;
4421 : }
4422 : if (current5_ == end5_) {
4423 : current5_ = begin5_;
4424 : ++current4_;
4425 : }
4426 : if (current4_ == end4_) {
4427 : current4_ = begin4_;
4428 : ++current3_;
4429 : }
4430 : if (current3_ == end3_) {
4431 : current3_ = begin3_;
4432 : ++current2_;
4433 : }
4434 : if (current2_ == end2_) {
4435 : current2_ = begin2_;
4436 : ++current1_;
4437 : }
4438 : ComputeCurrentValue();
4439 : }
4440 : virtual ParamIteratorInterface<ParamType>* Clone() const {
4441 : return new Iterator(*this);
4442 : }
4443 : virtual const ParamType* Current() const { return ¤t_value_; }
4444 : virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
4445 : // Having the same base generator guarantees that the other
4446 : // iterator is of the same type and we can downcast.
4447 : GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
4448 : << "The program attempted to compare iterators "
4449 : << "from different generators." << std::endl;
4450 : const Iterator* typed_other =
4451 : CheckedDowncastToActualType<const Iterator>(&other);
4452 : // We must report iterators equal if they both point beyond their
4453 : // respective ranges. That can happen in a variety of fashions,
4454 : // so we have to consult AtEnd().
4455 : return (AtEnd() && typed_other->AtEnd()) ||
4456 : (
4457 : current1_ == typed_other->current1_ &&
4458 : current2_ == typed_other->current2_ &&
4459 : current3_ == typed_other->current3_ &&
4460 : current4_ == typed_other->current4_ &&
4461 : current5_ == typed_other->current5_ &&
4462 : current6_ == typed_other->current6_ &&
4463 : current7_ == typed_other->current7_ &&
4464 : current8_ == typed_other->current8_ &&
4465 : current9_ == typed_other->current9_);
4466 : }
4467 :
4468 : private:
4469 : Iterator(const Iterator& other)
4470 : : base_(other.base_),
4471 : begin1_(other.begin1_),
4472 : end1_(other.end1_),
4473 : current1_(other.current1_),
4474 : begin2_(other.begin2_),
4475 : end2_(other.end2_),
4476 : current2_(other.current2_),
4477 : begin3_(other.begin3_),
4478 : end3_(other.end3_),
4479 : current3_(other.current3_),
4480 : begin4_(other.begin4_),
4481 : end4_(other.end4_),
4482 : current4_(other.current4_),
4483 : begin5_(other.begin5_),
4484 : end5_(other.end5_),
4485 : current5_(other.current5_),
4486 : begin6_(other.begin6_),
4487 : end6_(other.end6_),
4488 : current6_(other.current6_),
4489 : begin7_(other.begin7_),
4490 : end7_(other.end7_),
4491 : current7_(other.current7_),
4492 : begin8_(other.begin8_),
4493 : end8_(other.end8_),
4494 : current8_(other.current8_),
4495 : begin9_(other.begin9_),
4496 : end9_(other.end9_),
4497 : current9_(other.current9_) {
4498 : ComputeCurrentValue();
4499 : }
4500 :
4501 : void ComputeCurrentValue() {
4502 : if (!AtEnd())
4503 : current_value_ = ParamType(*current1_, *current2_, *current3_,
4504 : *current4_, *current5_, *current6_, *current7_, *current8_,
4505 : *current9_);
4506 : }
4507 : bool AtEnd() const {
4508 : // We must report iterator past the end of the range when either of the
4509 : // component iterators has reached the end of its range.
4510 : return
4511 : current1_ == end1_ ||
4512 : current2_ == end2_ ||
4513 : current3_ == end3_ ||
4514 : current4_ == end4_ ||
4515 : current5_ == end5_ ||
4516 : current6_ == end6_ ||
4517 : current7_ == end7_ ||
4518 : current8_ == end8_ ||
4519 : current9_ == end9_;
4520 : }
4521 :
4522 : // No implementation - assignment is unsupported.
4523 : void operator=(const Iterator& other);
4524 :
4525 : const ParamGeneratorInterface<ParamType>* const base_;
4526 : // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
4527 : // current[i]_ is the actual traversing iterator.
4528 : const typename ParamGenerator<T1>::iterator begin1_;
4529 : const typename ParamGenerator<T1>::iterator end1_;
4530 : typename ParamGenerator<T1>::iterator current1_;
4531 : const typename ParamGenerator<T2>::iterator begin2_;
4532 : const typename ParamGenerator<T2>::iterator end2_;
4533 : typename ParamGenerator<T2>::iterator current2_;
4534 : const typename ParamGenerator<T3>::iterator begin3_;
4535 : const typename ParamGenerator<T3>::iterator end3_;
4536 : typename ParamGenerator<T3>::iterator current3_;
4537 : const typename ParamGenerator<T4>::iterator begin4_;
4538 : const typename ParamGenerator<T4>::iterator end4_;
4539 : typename ParamGenerator<T4>::iterator current4_;
4540 : const typename ParamGenerator<T5>::iterator begin5_;
4541 : const typename ParamGenerator<T5>::iterator end5_;
4542 : typename ParamGenerator<T5>::iterator current5_;
4543 : const typename ParamGenerator<T6>::iterator begin6_;
4544 : const typename ParamGenerator<T6>::iterator end6_;
4545 : typename ParamGenerator<T6>::iterator current6_;
4546 : const typename ParamGenerator<T7>::iterator begin7_;
4547 : const typename ParamGenerator<T7>::iterator end7_;
4548 : typename ParamGenerator<T7>::iterator current7_;
4549 : const typename ParamGenerator<T8>::iterator begin8_;
4550 : const typename ParamGenerator<T8>::iterator end8_;
4551 : typename ParamGenerator<T8>::iterator current8_;
4552 : const typename ParamGenerator<T9>::iterator begin9_;
4553 : const typename ParamGenerator<T9>::iterator end9_;
4554 : typename ParamGenerator<T9>::iterator current9_;
4555 : ParamType current_value_;
4556 : }; // class CartesianProductGenerator9::Iterator
4557 :
4558 : // No implementation - assignment is unsupported.
4559 : void operator=(const CartesianProductGenerator9& other);
4560 :
4561 : const ParamGenerator<T1> g1_;
4562 : const ParamGenerator<T2> g2_;
4563 : const ParamGenerator<T3> g3_;
4564 : const ParamGenerator<T4> g4_;
4565 : const ParamGenerator<T5> g5_;
4566 : const ParamGenerator<T6> g6_;
4567 : const ParamGenerator<T7> g7_;
4568 : const ParamGenerator<T8> g8_;
4569 : const ParamGenerator<T9> g9_;
4570 : }; // class CartesianProductGenerator9
4571 :
4572 :
4573 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
4574 : typename T6, typename T7, typename T8, typename T9, typename T10>
4575 : class CartesianProductGenerator10
4576 : : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
4577 : T7, T8, T9, T10> > {
4578 : public:
4579 : typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ParamType;
4580 :
4581 : CartesianProductGenerator10(const ParamGenerator<T1>& g1,
4582 : const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
4583 : const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
4584 : const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
4585 : const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9,
4586 : const ParamGenerator<T10>& g10)
4587 : : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
4588 : g9_(g9), g10_(g10) {}
4589 : virtual ~CartesianProductGenerator10() {}
4590 :
4591 : virtual ParamIteratorInterface<ParamType>* Begin() const {
4592 : return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
4593 : g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
4594 : g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin(), g10_, g10_.begin());
4595 : }
4596 : virtual ParamIteratorInterface<ParamType>* End() const {
4597 : return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
4598 : g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
4599 : g8_.end(), g9_, g9_.end(), g10_, g10_.end());
4600 : }
4601 :
4602 : private:
4603 : class Iterator : public ParamIteratorInterface<ParamType> {
4604 : public:
4605 : Iterator(const ParamGeneratorInterface<ParamType>* base,
4606 : const ParamGenerator<T1>& g1,
4607 : const typename ParamGenerator<T1>::iterator& current1,
4608 : const ParamGenerator<T2>& g2,
4609 : const typename ParamGenerator<T2>::iterator& current2,
4610 : const ParamGenerator<T3>& g3,
4611 : const typename ParamGenerator<T3>::iterator& current3,
4612 : const ParamGenerator<T4>& g4,
4613 : const typename ParamGenerator<T4>::iterator& current4,
4614 : const ParamGenerator<T5>& g5,
4615 : const typename ParamGenerator<T5>::iterator& current5,
4616 : const ParamGenerator<T6>& g6,
4617 : const typename ParamGenerator<T6>::iterator& current6,
4618 : const ParamGenerator<T7>& g7,
4619 : const typename ParamGenerator<T7>::iterator& current7,
4620 : const ParamGenerator<T8>& g8,
4621 : const typename ParamGenerator<T8>::iterator& current8,
4622 : const ParamGenerator<T9>& g9,
4623 : const typename ParamGenerator<T9>::iterator& current9,
4624 : const ParamGenerator<T10>& g10,
4625 : const typename ParamGenerator<T10>::iterator& current10)
4626 : : base_(base),
4627 : begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
4628 : begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
4629 : begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
4630 : begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
4631 : begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
4632 : begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
4633 : begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
4634 : begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
4635 : begin9_(g9.begin()), end9_(g9.end()), current9_(current9),
4636 : begin10_(g10.begin()), end10_(g10.end()), current10_(current10) {
4637 : ComputeCurrentValue();
4638 : }
4639 : virtual ~Iterator() {}
4640 :
4641 : virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
4642 : return base_;
4643 : }
4644 : // Advance should not be called on beyond-of-range iterators
4645 : // so no component iterators must be beyond end of range, either.
4646 : virtual void Advance() {
4647 : assert(!AtEnd());
4648 : ++current10_;
4649 : if (current10_ == end10_) {
4650 : current10_ = begin10_;
4651 : ++current9_;
4652 : }
4653 : if (current9_ == end9_) {
4654 : current9_ = begin9_;
4655 : ++current8_;
4656 : }
4657 : if (current8_ == end8_) {
4658 : current8_ = begin8_;
4659 : ++current7_;
4660 : }
4661 : if (current7_ == end7_) {
4662 : current7_ = begin7_;
4663 : ++current6_;
4664 : }
4665 : if (current6_ == end6_) {
4666 : current6_ = begin6_;
4667 : ++current5_;
4668 : }
4669 : if (current5_ == end5_) {
4670 : current5_ = begin5_;
4671 : ++current4_;
4672 : }
4673 : if (current4_ == end4_) {
4674 : current4_ = begin4_;
4675 : ++current3_;
4676 : }
4677 : if (current3_ == end3_) {
4678 : current3_ = begin3_;
4679 : ++current2_;
4680 : }
4681 : if (current2_ == end2_) {
4682 : current2_ = begin2_;
4683 : ++current1_;
4684 : }
4685 : ComputeCurrentValue();
4686 : }
4687 : virtual ParamIteratorInterface<ParamType>* Clone() const {
4688 : return new Iterator(*this);
4689 : }
4690 : virtual const ParamType* Current() const { return ¤t_value_; }
4691 : virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
4692 : // Having the same base generator guarantees that the other
4693 : // iterator is of the same type and we can downcast.
4694 : GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
4695 : << "The program attempted to compare iterators "
4696 : << "from different generators." << std::endl;
4697 : const Iterator* typed_other =
4698 : CheckedDowncastToActualType<const Iterator>(&other);
4699 : // We must report iterators equal if they both point beyond their
4700 : // respective ranges. That can happen in a variety of fashions,
4701 : // so we have to consult AtEnd().
4702 : return (AtEnd() && typed_other->AtEnd()) ||
4703 : (
4704 : current1_ == typed_other->current1_ &&
4705 : current2_ == typed_other->current2_ &&
4706 : current3_ == typed_other->current3_ &&
4707 : current4_ == typed_other->current4_ &&
4708 : current5_ == typed_other->current5_ &&
4709 : current6_ == typed_other->current6_ &&
4710 : current7_ == typed_other->current7_ &&
4711 : current8_ == typed_other->current8_ &&
4712 : current9_ == typed_other->current9_ &&
4713 : current10_ == typed_other->current10_);
4714 : }
4715 :
4716 : private:
4717 : Iterator(const Iterator& other)
4718 : : base_(other.base_),
4719 : begin1_(other.begin1_),
4720 : end1_(other.end1_),
4721 : current1_(other.current1_),
4722 : begin2_(other.begin2_),
4723 : end2_(other.end2_),
4724 : current2_(other.current2_),
4725 : begin3_(other.begin3_),
4726 : end3_(other.end3_),
4727 : current3_(other.current3_),
4728 : begin4_(other.begin4_),
4729 : end4_(other.end4_),
4730 : current4_(other.current4_),
4731 : begin5_(other.begin5_),
4732 : end5_(other.end5_),
4733 : current5_(other.current5_),
4734 : begin6_(other.begin6_),
4735 : end6_(other.end6_),
4736 : current6_(other.current6_),
4737 : begin7_(other.begin7_),
4738 : end7_(other.end7_),
4739 : current7_(other.current7_),
4740 : begin8_(other.begin8_),
4741 : end8_(other.end8_),
4742 : current8_(other.current8_),
4743 : begin9_(other.begin9_),
4744 : end9_(other.end9_),
4745 : current9_(other.current9_),
4746 : begin10_(other.begin10_),
4747 : end10_(other.end10_),
4748 : current10_(other.current10_) {
4749 : ComputeCurrentValue();
4750 : }
4751 :
4752 : void ComputeCurrentValue() {
4753 : if (!AtEnd())
4754 : current_value_ = ParamType(*current1_, *current2_, *current3_,
4755 : *current4_, *current5_, *current6_, *current7_, *current8_,
4756 : *current9_, *current10_);
4757 : }
4758 : bool AtEnd() const {
4759 : // We must report iterator past the end of the range when either of the
4760 : // component iterators has reached the end of its range.
4761 : return
4762 : current1_ == end1_ ||
4763 : current2_ == end2_ ||
4764 : current3_ == end3_ ||
4765 : current4_ == end4_ ||
4766 : current5_ == end5_ ||
4767 : current6_ == end6_ ||
4768 : current7_ == end7_ ||
4769 : current8_ == end8_ ||
4770 : current9_ == end9_ ||
4771 : current10_ == end10_;
4772 : }
4773 :
4774 : // No implementation - assignment is unsupported.
4775 : void operator=(const Iterator& other);
4776 :
4777 : const ParamGeneratorInterface<ParamType>* const base_;
4778 : // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
4779 : // current[i]_ is the actual traversing iterator.
4780 : const typename ParamGenerator<T1>::iterator begin1_;
4781 : const typename ParamGenerator<T1>::iterator end1_;
4782 : typename ParamGenerator<T1>::iterator current1_;
4783 : const typename ParamGenerator<T2>::iterator begin2_;
4784 : const typename ParamGenerator<T2>::iterator end2_;
4785 : typename ParamGenerator<T2>::iterator current2_;
4786 : const typename ParamGenerator<T3>::iterator begin3_;
4787 : const typename ParamGenerator<T3>::iterator end3_;
4788 : typename ParamGenerator<T3>::iterator current3_;
4789 : const typename ParamGenerator<T4>::iterator begin4_;
4790 : const typename ParamGenerator<T4>::iterator end4_;
4791 : typename ParamGenerator<T4>::iterator current4_;
4792 : const typename ParamGenerator<T5>::iterator begin5_;
4793 : const typename ParamGenerator<T5>::iterator end5_;
4794 : typename ParamGenerator<T5>::iterator current5_;
4795 : const typename ParamGenerator<T6>::iterator begin6_;
4796 : const typename ParamGenerator<T6>::iterator end6_;
4797 : typename ParamGenerator<T6>::iterator current6_;
4798 : const typename ParamGenerator<T7>::iterator begin7_;
4799 : const typename ParamGenerator<T7>::iterator end7_;
4800 : typename ParamGenerator<T7>::iterator current7_;
4801 : const typename ParamGenerator<T8>::iterator begin8_;
4802 : const typename ParamGenerator<T8>::iterator end8_;
4803 : typename ParamGenerator<T8>::iterator current8_;
4804 : const typename ParamGenerator<T9>::iterator begin9_;
4805 : const typename ParamGenerator<T9>::iterator end9_;
4806 : typename ParamGenerator<T9>::iterator current9_;
4807 : const typename ParamGenerator<T10>::iterator begin10_;
4808 : const typename ParamGenerator<T10>::iterator end10_;
4809 : typename ParamGenerator<T10>::iterator current10_;
4810 : ParamType current_value_;
4811 : }; // class CartesianProductGenerator10::Iterator
4812 :
4813 : // No implementation - assignment is unsupported.
4814 : void operator=(const CartesianProductGenerator10& other);
4815 :
4816 : const ParamGenerator<T1> g1_;
4817 : const ParamGenerator<T2> g2_;
4818 : const ParamGenerator<T3> g3_;
4819 : const ParamGenerator<T4> g4_;
4820 : const ParamGenerator<T5> g5_;
4821 : const ParamGenerator<T6> g6_;
4822 : const ParamGenerator<T7> g7_;
4823 : const ParamGenerator<T8> g8_;
4824 : const ParamGenerator<T9> g9_;
4825 : const ParamGenerator<T10> g10_;
4826 : }; // class CartesianProductGenerator10
4827 :
4828 :
4829 : // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
4830 : //
4831 : // Helper classes providing Combine() with polymorphic features. They allow
4832 : // casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is
4833 : // convertible to U.
4834 : //
4835 : template <class Generator1, class Generator2>
4836 : class CartesianProductHolder2 {
4837 : public:
4838 : CartesianProductHolder2(const Generator1& g1, const Generator2& g2)
4839 : : g1_(g1), g2_(g2) {}
4840 : template <typename T1, typename T2>
4841 : operator ParamGenerator< ::std::tr1::tuple<T1, T2> >() const {
4842 : return ParamGenerator< ::std::tr1::tuple<T1, T2> >(
4843 : new CartesianProductGenerator2<T1, T2>(
4844 : static_cast<ParamGenerator<T1> >(g1_),
4845 : static_cast<ParamGenerator<T2> >(g2_)));
4846 : }
4847 :
4848 : private:
4849 : // No implementation - assignment is unsupported.
4850 : void operator=(const CartesianProductHolder2& other);
4851 :
4852 : const Generator1 g1_;
4853 : const Generator2 g2_;
4854 : }; // class CartesianProductHolder2
4855 :
4856 : template <class Generator1, class Generator2, class Generator3>
4857 : class CartesianProductHolder3 {
4858 : public:
4859 : CartesianProductHolder3(const Generator1& g1, const Generator2& g2,
4860 : const Generator3& g3)
4861 : : g1_(g1), g2_(g2), g3_(g3) {}
4862 : template <typename T1, typename T2, typename T3>
4863 : operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3> >() const {
4864 : return ParamGenerator< ::std::tr1::tuple<T1, T2, T3> >(
4865 : new CartesianProductGenerator3<T1, T2, T3>(
4866 : static_cast<ParamGenerator<T1> >(g1_),
4867 : static_cast<ParamGenerator<T2> >(g2_),
4868 : static_cast<ParamGenerator<T3> >(g3_)));
4869 : }
4870 :
4871 : private:
4872 : // No implementation - assignment is unsupported.
4873 : void operator=(const CartesianProductHolder3& other);
4874 :
4875 : const Generator1 g1_;
4876 : const Generator2 g2_;
4877 : const Generator3 g3_;
4878 : }; // class CartesianProductHolder3
4879 :
4880 : template <class Generator1, class Generator2, class Generator3,
4881 : class Generator4>
4882 : class CartesianProductHolder4 {
4883 : public:
4884 : CartesianProductHolder4(const Generator1& g1, const Generator2& g2,
4885 : const Generator3& g3, const Generator4& g4)
4886 : : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
4887 : template <typename T1, typename T2, typename T3, typename T4>
4888 : operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4> >() const {
4889 : return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4> >(
4890 : new CartesianProductGenerator4<T1, T2, T3, T4>(
4891 : static_cast<ParamGenerator<T1> >(g1_),
4892 : static_cast<ParamGenerator<T2> >(g2_),
4893 : static_cast<ParamGenerator<T3> >(g3_),
4894 : static_cast<ParamGenerator<T4> >(g4_)));
4895 : }
4896 :
4897 : private:
4898 : // No implementation - assignment is unsupported.
4899 : void operator=(const CartesianProductHolder4& other);
4900 :
4901 : const Generator1 g1_;
4902 : const Generator2 g2_;
4903 : const Generator3 g3_;
4904 : const Generator4 g4_;
4905 : }; // class CartesianProductHolder4
4906 :
4907 : template <class Generator1, class Generator2, class Generator3,
4908 : class Generator4, class Generator5>
4909 : class CartesianProductHolder5 {
4910 : public:
4911 : CartesianProductHolder5(const Generator1& g1, const Generator2& g2,
4912 : const Generator3& g3, const Generator4& g4, const Generator5& g5)
4913 : : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
4914 : template <typename T1, typename T2, typename T3, typename T4, typename T5>
4915 : operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5> >() const {
4916 : return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5> >(
4917 : new CartesianProductGenerator5<T1, T2, T3, T4, T5>(
4918 : static_cast<ParamGenerator<T1> >(g1_),
4919 : static_cast<ParamGenerator<T2> >(g2_),
4920 : static_cast<ParamGenerator<T3> >(g3_),
4921 : static_cast<ParamGenerator<T4> >(g4_),
4922 : static_cast<ParamGenerator<T5> >(g5_)));
4923 : }
4924 :
4925 : private:
4926 : // No implementation - assignment is unsupported.
4927 : void operator=(const CartesianProductHolder5& other);
4928 :
4929 : const Generator1 g1_;
4930 : const Generator2 g2_;
4931 : const Generator3 g3_;
4932 : const Generator4 g4_;
4933 : const Generator5 g5_;
4934 : }; // class CartesianProductHolder5
4935 :
4936 : template <class Generator1, class Generator2, class Generator3,
4937 : class Generator4, class Generator5, class Generator6>
4938 : class CartesianProductHolder6 {
4939 : public:
4940 : CartesianProductHolder6(const Generator1& g1, const Generator2& g2,
4941 : const Generator3& g3, const Generator4& g4, const Generator5& g5,
4942 : const Generator6& g6)
4943 : : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
4944 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
4945 : typename T6>
4946 : operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> >() const {
4947 : return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> >(
4948 : new CartesianProductGenerator6<T1, T2, T3, T4, T5, T6>(
4949 : static_cast<ParamGenerator<T1> >(g1_),
4950 : static_cast<ParamGenerator<T2> >(g2_),
4951 : static_cast<ParamGenerator<T3> >(g3_),
4952 : static_cast<ParamGenerator<T4> >(g4_),
4953 : static_cast<ParamGenerator<T5> >(g5_),
4954 : static_cast<ParamGenerator<T6> >(g6_)));
4955 : }
4956 :
4957 : private:
4958 : // No implementation - assignment is unsupported.
4959 : void operator=(const CartesianProductHolder6& other);
4960 :
4961 : const Generator1 g1_;
4962 : const Generator2 g2_;
4963 : const Generator3 g3_;
4964 : const Generator4 g4_;
4965 : const Generator5 g5_;
4966 : const Generator6 g6_;
4967 : }; // class CartesianProductHolder6
4968 :
4969 : template <class Generator1, class Generator2, class Generator3,
4970 : class Generator4, class Generator5, class Generator6, class Generator7>
4971 : class CartesianProductHolder7 {
4972 : public:
4973 : CartesianProductHolder7(const Generator1& g1, const Generator2& g2,
4974 : const Generator3& g3, const Generator4& g4, const Generator5& g5,
4975 : const Generator6& g6, const Generator7& g7)
4976 : : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
4977 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
4978 : typename T6, typename T7>
4979 : operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
4980 : T7> >() const {
4981 : return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7> >(
4982 : new CartesianProductGenerator7<T1, T2, T3, T4, T5, T6, T7>(
4983 : static_cast<ParamGenerator<T1> >(g1_),
4984 : static_cast<ParamGenerator<T2> >(g2_),
4985 : static_cast<ParamGenerator<T3> >(g3_),
4986 : static_cast<ParamGenerator<T4> >(g4_),
4987 : static_cast<ParamGenerator<T5> >(g5_),
4988 : static_cast<ParamGenerator<T6> >(g6_),
4989 : static_cast<ParamGenerator<T7> >(g7_)));
4990 : }
4991 :
4992 : private:
4993 : // No implementation - assignment is unsupported.
4994 : void operator=(const CartesianProductHolder7& other);
4995 :
4996 : const Generator1 g1_;
4997 : const Generator2 g2_;
4998 : const Generator3 g3_;
4999 : const Generator4 g4_;
5000 : const Generator5 g5_;
5001 : const Generator6 g6_;
5002 : const Generator7 g7_;
5003 : }; // class CartesianProductHolder7
5004 :
5005 : template <class Generator1, class Generator2, class Generator3,
5006 : class Generator4, class Generator5, class Generator6, class Generator7,
5007 : class Generator8>
5008 : class CartesianProductHolder8 {
5009 : public:
5010 : CartesianProductHolder8(const Generator1& g1, const Generator2& g2,
5011 : const Generator3& g3, const Generator4& g4, const Generator5& g5,
5012 : const Generator6& g6, const Generator7& g7, const Generator8& g8)
5013 : : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
5014 : g8_(g8) {}
5015 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
5016 : typename T6, typename T7, typename T8>
5017 : operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7,
5018 : T8> >() const {
5019 : return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8> >(
5020 : new CartesianProductGenerator8<T1, T2, T3, T4, T5, T6, T7, T8>(
5021 : static_cast<ParamGenerator<T1> >(g1_),
5022 : static_cast<ParamGenerator<T2> >(g2_),
5023 : static_cast<ParamGenerator<T3> >(g3_),
5024 : static_cast<ParamGenerator<T4> >(g4_),
5025 : static_cast<ParamGenerator<T5> >(g5_),
5026 : static_cast<ParamGenerator<T6> >(g6_),
5027 : static_cast<ParamGenerator<T7> >(g7_),
5028 : static_cast<ParamGenerator<T8> >(g8_)));
5029 : }
5030 :
5031 : private:
5032 : // No implementation - assignment is unsupported.
5033 : void operator=(const CartesianProductHolder8& other);
5034 :
5035 : const Generator1 g1_;
5036 : const Generator2 g2_;
5037 : const Generator3 g3_;
5038 : const Generator4 g4_;
5039 : const Generator5 g5_;
5040 : const Generator6 g6_;
5041 : const Generator7 g7_;
5042 : const Generator8 g8_;
5043 : }; // class CartesianProductHolder8
5044 :
5045 : template <class Generator1, class Generator2, class Generator3,
5046 : class Generator4, class Generator5, class Generator6, class Generator7,
5047 : class Generator8, class Generator9>
5048 : class CartesianProductHolder9 {
5049 : public:
5050 : CartesianProductHolder9(const Generator1& g1, const Generator2& g2,
5051 : const Generator3& g3, const Generator4& g4, const Generator5& g5,
5052 : const Generator6& g6, const Generator7& g7, const Generator8& g8,
5053 : const Generator9& g9)
5054 : : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
5055 : g9_(g9) {}
5056 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
5057 : typename T6, typename T7, typename T8, typename T9>
5058 : operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
5059 : T9> >() const {
5060 : return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
5061 : T9> >(
5062 : new CartesianProductGenerator9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
5063 : static_cast<ParamGenerator<T1> >(g1_),
5064 : static_cast<ParamGenerator<T2> >(g2_),
5065 : static_cast<ParamGenerator<T3> >(g3_),
5066 : static_cast<ParamGenerator<T4> >(g4_),
5067 : static_cast<ParamGenerator<T5> >(g5_),
5068 : static_cast<ParamGenerator<T6> >(g6_),
5069 : static_cast<ParamGenerator<T7> >(g7_),
5070 : static_cast<ParamGenerator<T8> >(g8_),
5071 : static_cast<ParamGenerator<T9> >(g9_)));
5072 : }
5073 :
5074 : private:
5075 : // No implementation - assignment is unsupported.
5076 : void operator=(const CartesianProductHolder9& other);
5077 :
5078 : const Generator1 g1_;
5079 : const Generator2 g2_;
5080 : const Generator3 g3_;
5081 : const Generator4 g4_;
5082 : const Generator5 g5_;
5083 : const Generator6 g6_;
5084 : const Generator7 g7_;
5085 : const Generator8 g8_;
5086 : const Generator9 g9_;
5087 : }; // class CartesianProductHolder9
5088 :
5089 : template <class Generator1, class Generator2, class Generator3,
5090 : class Generator4, class Generator5, class Generator6, class Generator7,
5091 : class Generator8, class Generator9, class Generator10>
5092 : class CartesianProductHolder10 {
5093 : public:
5094 : CartesianProductHolder10(const Generator1& g1, const Generator2& g2,
5095 : const Generator3& g3, const Generator4& g4, const Generator5& g5,
5096 : const Generator6& g6, const Generator7& g7, const Generator8& g8,
5097 : const Generator9& g9, const Generator10& g10)
5098 : : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
5099 : g9_(g9), g10_(g10) {}
5100 : template <typename T1, typename T2, typename T3, typename T4, typename T5,
5101 : typename T6, typename T7, typename T8, typename T9, typename T10>
5102 : operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
5103 : T9, T10> >() const {
5104 : return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
5105 : T9, T10> >(
5106 : new CartesianProductGenerator10<T1, T2, T3, T4, T5, T6, T7, T8, T9,
5107 : T10>(
5108 : static_cast<ParamGenerator<T1> >(g1_),
5109 : static_cast<ParamGenerator<T2> >(g2_),
5110 : static_cast<ParamGenerator<T3> >(g3_),
5111 : static_cast<ParamGenerator<T4> >(g4_),
5112 : static_cast<ParamGenerator<T5> >(g5_),
5113 : static_cast<ParamGenerator<T6> >(g6_),
5114 : static_cast<ParamGenerator<T7> >(g7_),
5115 : static_cast<ParamGenerator<T8> >(g8_),
5116 : static_cast<ParamGenerator<T9> >(g9_),
5117 : static_cast<ParamGenerator<T10> >(g10_)));
5118 : }
5119 :
5120 : private:
5121 : // No implementation - assignment is unsupported.
5122 : void operator=(const CartesianProductHolder10& other);
5123 :
5124 : const Generator1 g1_;
5125 : const Generator2 g2_;
5126 : const Generator3 g3_;
5127 : const Generator4 g4_;
5128 : const Generator5 g5_;
5129 : const Generator6 g6_;
5130 : const Generator7 g7_;
5131 : const Generator8 g8_;
5132 : const Generator9 g9_;
5133 : const Generator10 g10_;
5134 : }; // class CartesianProductHolder10
5135 :
5136 : # endif // GTEST_HAS_COMBINE
5137 :
5138 : } // namespace internal
5139 : } // namespace testing
5140 :
5141 : #endif // GTEST_HAS_PARAM_TEST
5142 :
5143 : #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
|
