include/gtest/internal/gtest-param-util-generated.h

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