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