inference-engine/tests/libs/gtest/googletest/include/gtest/internal/gtest-param-util-generated.h

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