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