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