← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mozc/oneiric

« back to all changes in this revision

Viewing changes to third_party/gtest/include/gtest/internal/gtest-param-util-generated.h

  • Committer: Bazaar Package Importer
  • Author(s): Nobuhiro Iwamatsu
  • Date: 2010-07-14 03:26:47 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100714032647-13qjisj6m8cm8jdx
Tags: 0.12.410.102-1
http://bugs.debian.org/588971
http://bugs.debian.org/588972
* New upstream release (Closes: #588971).
  - Add mozc-server, mozc-utils-gui and scim-mozc packages.
* Update debian/rules.
  Add --gypdir option to build_mozc.py.
* Update debian/control.
  - Bumped standards-version to 3.9.0.
  - Update description.
* Add mozc icon (Closes: #588972).
* Add patch which revises issue 18.
  ibus_mozc_issue18.patch
* kFreeBSD build support.
  support_kfreebsd.patch

Show diffs side-by-side

added added

removed removed

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