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 explicit ValueArray1(T1 v1) : v1_(v1) {}
80
81 template <typename T>
82 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 ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}
95
96 template <typename T>
97 operator ParamGenerator<T>() const {
98 const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_)};
99 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 ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3),
135 v4_(v4) {}
136
137 template <typename T>
138 operator ParamGenerator<T>() const {
139 const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
140 static_cast<T>(v3_), static_cast<T>(v4_)};
141 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_