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


fcl
Author(s):
autogenerated on Fri Apr 2 2021 02:38:00