gtest-param-util-generated.h source code [temp/googletest_ep-prefix/src/googletest_ep/include/gtest/internal/gtest-param-util-generated.h]

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

Browse the source code of temp/googletest_ep-prefix/src/googletest_ep/include/gtest/internal/gtest-param-util-generated.h