OpenCores
URL https://opencores.org/ocsvn/s80186/s80186/trunk

Subversion Repositories s80186

[/] [s80186/] [trunk/] [vendor/] [googletest/] [googletest/] [include/] [gtest/] [internal/] [gtest-param-util-generated.h] - Blame information for rev 2

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 jamieiles
// 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_

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.