Faiss

- Main Page
- Namespaces
- Classes
- Files

- File List

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