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