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