Qucs-core  0.0.19
gtest-param-util-generated.h
Go to the documentation of this file.
00001 // This file was GENERATED by command:
00002 //     pump.py gtest-param-util-generated.h.pump
00003 // DO NOT EDIT BY HAND!!!
00004 
00005 // Copyright 2008 Google Inc.
00006 // All Rights Reserved.
00007 //
00008 // Redistribution and use in source and binary forms, with or without
00009 // modification, are permitted provided that the following conditions are
00010 // met:
00011 //
00012 //     * Redistributions of source code must retain the above copyright
00013 // notice, this list of conditions and the following disclaimer.
00014 //     * Redistributions in binary form must reproduce the above
00015 // copyright notice, this list of conditions and the following disclaimer
00016 // in the documentation and/or other materials provided with the
00017 // distribution.
00018 //     * Neither the name of Google Inc. nor the names of its
00019 // contributors may be used to endorse or promote products derived from
00020 // this software without specific prior written permission.
00021 //
00022 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00023 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00024 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00025 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
00026 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00027 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00028 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00029 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00030 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00031 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00032 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00033 //
00034 // Author: vladl@google.com (Vlad Losev)
00035 
00036 // Type and function utilities for implementing parameterized tests.
00037 // This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
00038 //
00039 // Currently Google Test supports at most 50 arguments in Values,
00040 // and at most 10 arguments in Combine. Please contact
00041 // googletestframework@googlegroups.com if you need more.
00042 // Please note that the number of arguments to Combine is limited
00043 // by the maximum arity of the implementation of tr1::tuple which is
00044 // currently set at 10.
00045 
00046 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
00047 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
00048 
00049 // scripts/fuse_gtest.py depends on gtest's own header being #included
00050 // *unconditionally*.  Therefore these #includes cannot be moved
00051 // inside #if GTEST_HAS_PARAM_TEST.
00052 #include "gtest/internal/gtest-param-util.h"
00053 #include "gtest/internal/gtest-port.h"
00054 
00055 #if GTEST_HAS_PARAM_TEST
00056 
00057 namespace testing {
00058 
00059 // Forward declarations of ValuesIn(), which is implemented in
00060 // include/gtest/gtest-param-test.h.
00061 template <typename ForwardIterator>
00062 internal::ParamGenerator<
00063   typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
00064 ValuesIn(ForwardIterator begin, ForwardIterator end);
00065 
00066 template <typename T, size_t N>
00067 internal::ParamGenerator<T> ValuesIn(const T (&array)[N]);
00068 
00069 template <class Container>
00070 internal::ParamGenerator<typename Container::value_type> ValuesIn(
00071     const Container& container);
00072 
00073 namespace internal {
00074 
00075 // Used in the Values() function to provide polymorphic capabilities.
00076 template <typename T1>
00077 class ValueArray1 {
00078  public:
00079   explicit ValueArray1(T1 v1) : v1_(v1) {}
00080 
00081   template <typename T>
00082   operator ParamGenerator<T>() const { return ValuesIn(&v1_, &v1_ + 1); }
00083 
00084  private:
00085   // No implementation - assignment is unsupported.
00086   void operator=(const ValueArray1& other);
00087 
00088   const T1 v1_;
00089 };
00090 
00091 template <typename T1, typename T2>
00092 class ValueArray2 {
00093  public:
00094   ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}
00095 
00096   template <typename T>
00097   operator ParamGenerator<T>() const {
00098     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_)};
00099     return ValuesIn(array);
00100   }
00101 
00102  private:
00103   // No implementation - assignment is unsupported.
00104   void operator=(const ValueArray2& other);
00105 
00106   const T1 v1_;
00107   const T2 v2_;
00108 };
00109 
00110 template <typename T1, typename T2, typename T3>
00111 class ValueArray3 {
00112  public:
00113   ValueArray3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {}
00114 
00115   template <typename T>
00116   operator ParamGenerator<T>() const {
00117     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00118         static_cast<T>(v3_)};
00119     return ValuesIn(array);
00120   }
00121 
00122  private:
00123   // No implementation - assignment is unsupported.
00124   void operator=(const ValueArray3& other);
00125 
00126   const T1 v1_;
00127   const T2 v2_;
00128   const T3 v3_;
00129 };
00130 
00131 template <typename T1, typename T2, typename T3, typename T4>
00132 class ValueArray4 {
00133  public:
00134   ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3),
00135       v4_(v4) {}
00136 
00137   template <typename T>
00138   operator ParamGenerator<T>() const {
00139     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00140         static_cast<T>(v3_), static_cast<T>(v4_)};
00141     return ValuesIn(array);
00142   }
00143 
00144  private:
00145   // No implementation - assignment is unsupported.
00146   void operator=(const ValueArray4& other);
00147 
00148   const T1 v1_;
00149   const T2 v2_;
00150   const T3 v3_;
00151   const T4 v4_;
00152 };
00153 
00154 template <typename T1, typename T2, typename T3, typename T4, typename T5>
00155 class ValueArray5 {
00156  public:
00157   ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3),
00158       v4_(v4), v5_(v5) {}
00159 
00160   template <typename T>
00161   operator ParamGenerator<T>() const {
00162     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00163         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_)};
00164     return ValuesIn(array);
00165   }
00166 
00167  private:
00168   // No implementation - assignment is unsupported.
00169   void operator=(const ValueArray5& other);
00170 
00171   const T1 v1_;
00172   const T2 v2_;
00173   const T3 v3_;
00174   const T4 v4_;
00175   const T5 v5_;
00176 };
00177 
00178 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00179     typename T6>
00180 class ValueArray6 {
00181  public:
00182   ValueArray6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) : v1_(v1), v2_(v2),
00183       v3_(v3), v4_(v4), v5_(v5), v6_(v6) {}
00184 
00185   template <typename T>
00186   operator ParamGenerator<T>() const {
00187     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00188         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00189         static_cast<T>(v6_)};
00190     return ValuesIn(array);
00191   }
00192 
00193  private:
00194   // No implementation - assignment is unsupported.
00195   void operator=(const ValueArray6& other);
00196 
00197   const T1 v1_;
00198   const T2 v2_;
00199   const T3 v3_;
00200   const T4 v4_;
00201   const T5 v5_;
00202   const T6 v6_;
00203 };
00204 
00205 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00206     typename T6, typename T7>
00207 class ValueArray7 {
00208  public:
00209   ValueArray7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) : v1_(v1),
00210       v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7) {}
00211 
00212   template <typename T>
00213   operator ParamGenerator<T>() const {
00214     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00215         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00216         static_cast<T>(v6_), static_cast<T>(v7_)};
00217     return ValuesIn(array);
00218   }
00219 
00220  private:
00221   // No implementation - assignment is unsupported.
00222   void operator=(const ValueArray7& other);
00223 
00224   const T1 v1_;
00225   const T2 v2_;
00226   const T3 v3_;
00227   const T4 v4_;
00228   const T5 v5_;
00229   const T6 v6_;
00230   const T7 v7_;
00231 };
00232 
00233 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00234     typename T6, typename T7, typename T8>
00235 class ValueArray8 {
00236  public:
00237   ValueArray8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
00238       T8 v8) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
00239       v8_(v8) {}
00240 
00241   template <typename T>
00242   operator ParamGenerator<T>() const {
00243     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00244         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00245         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_)};
00246     return ValuesIn(array);
00247   }
00248 
00249  private:
00250   // No implementation - assignment is unsupported.
00251   void operator=(const ValueArray8& other);
00252 
00253   const T1 v1_;
00254   const T2 v2_;
00255   const T3 v3_;
00256   const T4 v4_;
00257   const T5 v5_;
00258   const T6 v6_;
00259   const T7 v7_;
00260   const T8 v8_;
00261 };
00262 
00263 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00264     typename T6, typename T7, typename T8, typename T9>
00265 class ValueArray9 {
00266  public:
00267   ValueArray9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
00268       T9 v9) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
00269       v8_(v8), v9_(v9) {}
00270 
00271   template <typename T>
00272   operator ParamGenerator<T>() const {
00273     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00274         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00275         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00276         static_cast<T>(v9_)};
00277     return ValuesIn(array);
00278   }
00279 
00280  private:
00281   // No implementation - assignment is unsupported.
00282   void operator=(const ValueArray9& other);
00283 
00284   const T1 v1_;
00285   const T2 v2_;
00286   const T3 v3_;
00287   const T4 v4_;
00288   const T5 v5_;
00289   const T6 v6_;
00290   const T7 v7_;
00291   const T8 v8_;
00292   const T9 v9_;
00293 };
00294 
00295 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00296     typename T6, typename T7, typename T8, typename T9, typename T10>
00297 class ValueArray10 {
00298  public:
00299   ValueArray10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00300       T10 v10) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
00301       v8_(v8), v9_(v9), v10_(v10) {}
00302 
00303   template <typename T>
00304   operator ParamGenerator<T>() const {
00305     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00306         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00307         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00308         static_cast<T>(v9_), static_cast<T>(v10_)};
00309     return ValuesIn(array);
00310   }
00311 
00312  private:
00313   // No implementation - assignment is unsupported.
00314   void operator=(const ValueArray10& other);
00315 
00316   const T1 v1_;
00317   const T2 v2_;
00318   const T3 v3_;
00319   const T4 v4_;
00320   const T5 v5_;
00321   const T6 v6_;
00322   const T7 v7_;
00323   const T8 v8_;
00324   const T9 v9_;
00325   const T10 v10_;
00326 };
00327 
00328 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00329     typename T6, typename T7, typename T8, typename T9, typename T10,
00330     typename T11>
00331 class ValueArray11 {
00332  public:
00333   ValueArray11(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00334       T10 v10, T11 v11) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
00335       v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11) {}
00336 
00337   template <typename T>
00338   operator ParamGenerator<T>() const {
00339     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00340         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00341         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00342         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_)};
00343     return ValuesIn(array);
00344   }
00345 
00346  private:
00347   // No implementation - assignment is unsupported.
00348   void operator=(const ValueArray11& other);
00349 
00350   const T1 v1_;
00351   const T2 v2_;
00352   const T3 v3_;
00353   const T4 v4_;
00354   const T5 v5_;
00355   const T6 v6_;
00356   const T7 v7_;
00357   const T8 v8_;
00358   const T9 v9_;
00359   const T10 v10_;
00360   const T11 v11_;
00361 };
00362 
00363 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00364     typename T6, typename T7, typename T8, typename T9, typename T10,
00365     typename T11, typename T12>
00366 class ValueArray12 {
00367  public:
00368   ValueArray12(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00369       T10 v10, T11 v11, T12 v12) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
00370       v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12) {}
00371 
00372   template <typename T>
00373   operator ParamGenerator<T>() const {
00374     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00375         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00376         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00377         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
00378         static_cast<T>(v12_)};
00379     return ValuesIn(array);
00380   }
00381 
00382  private:
00383   // No implementation - assignment is unsupported.
00384   void operator=(const ValueArray12& other);
00385 
00386   const T1 v1_;
00387   const T2 v2_;
00388   const T3 v3_;
00389   const T4 v4_;
00390   const T5 v5_;
00391   const T6 v6_;
00392   const T7 v7_;
00393   const T8 v8_;
00394   const T9 v9_;
00395   const T10 v10_;
00396   const T11 v11_;
00397   const T12 v12_;
00398 };
00399 
00400 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00401     typename T6, typename T7, typename T8, typename T9, typename T10,
00402     typename T11, typename T12, typename T13>
00403 class ValueArray13 {
00404  public:
00405   ValueArray13(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00406       T10 v10, T11 v11, T12 v12, T13 v13) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
00407       v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
00408       v12_(v12), v13_(v13) {}
00409 
00410   template <typename T>
00411   operator ParamGenerator<T>() const {
00412     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00413         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00414         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00415         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
00416         static_cast<T>(v12_), static_cast<T>(v13_)};
00417     return ValuesIn(array);
00418   }
00419 
00420  private:
00421   // No implementation - assignment is unsupported.
00422   void operator=(const ValueArray13& other);
00423 
00424   const T1 v1_;
00425   const T2 v2_;
00426   const T3 v3_;
00427   const T4 v4_;
00428   const T5 v5_;
00429   const T6 v6_;
00430   const T7 v7_;
00431   const T8 v8_;
00432   const T9 v9_;
00433   const T10 v10_;
00434   const T11 v11_;
00435   const T12 v12_;
00436   const T13 v13_;
00437 };
00438 
00439 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00440     typename T6, typename T7, typename T8, typename T9, typename T10,
00441     typename T11, typename T12, typename T13, typename T14>
00442 class ValueArray14 {
00443  public:
00444   ValueArray14(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00445       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) : v1_(v1), v2_(v2), v3_(v3),
00446       v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
00447       v11_(v11), v12_(v12), v13_(v13), v14_(v14) {}
00448 
00449   template <typename T>
00450   operator ParamGenerator<T>() const {
00451     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00452         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00453         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00454         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
00455         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_)};
00456     return ValuesIn(array);
00457   }
00458 
00459  private:
00460   // No implementation - assignment is unsupported.
00461   void operator=(const ValueArray14& other);
00462 
00463   const T1 v1_;
00464   const T2 v2_;
00465   const T3 v3_;
00466   const T4 v4_;
00467   const T5 v5_;
00468   const T6 v6_;
00469   const T7 v7_;
00470   const T8 v8_;
00471   const T9 v9_;
00472   const T10 v10_;
00473   const T11 v11_;
00474   const T12 v12_;
00475   const T13 v13_;
00476   const T14 v14_;
00477 };
00478 
00479 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00480     typename T6, typename T7, typename T8, typename T9, typename T10,
00481     typename T11, typename T12, typename T13, typename T14, typename T15>
00482 class ValueArray15 {
00483  public:
00484   ValueArray15(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00485       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) : v1_(v1), v2_(v2),
00486       v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
00487       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15) {}
00488 
00489   template <typename T>
00490   operator ParamGenerator<T>() const {
00491     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00492         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00493         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00494         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
00495         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
00496         static_cast<T>(v15_)};
00497     return ValuesIn(array);
00498   }
00499 
00500  private:
00501   // No implementation - assignment is unsupported.
00502   void operator=(const ValueArray15& other);
00503 
00504   const T1 v1_;
00505   const T2 v2_;
00506   const T3 v3_;
00507   const T4 v4_;
00508   const T5 v5_;
00509   const T6 v6_;
00510   const T7 v7_;
00511   const T8 v8_;
00512   const T9 v9_;
00513   const T10 v10_;
00514   const T11 v11_;
00515   const T12 v12_;
00516   const T13 v13_;
00517   const T14 v14_;
00518   const T15 v15_;
00519 };
00520 
00521 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00522     typename T6, typename T7, typename T8, typename T9, typename T10,
00523     typename T11, typename T12, typename T13, typename T14, typename T15,
00524     typename T16>
00525 class ValueArray16 {
00526  public:
00527   ValueArray16(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00528       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) : v1_(v1),
00529       v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
00530       v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
00531       v16_(v16) {}
00532 
00533   template <typename T>
00534   operator ParamGenerator<T>() const {
00535     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00536         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00537         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00538         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
00539         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
00540         static_cast<T>(v15_), static_cast<T>(v16_)};
00541     return ValuesIn(array);
00542   }
00543 
00544  private:
00545   // No implementation - assignment is unsupported.
00546   void operator=(const ValueArray16& other);
00547 
00548   const T1 v1_;
00549   const T2 v2_;
00550   const T3 v3_;
00551   const T4 v4_;
00552   const T5 v5_;
00553   const T6 v6_;
00554   const T7 v7_;
00555   const T8 v8_;
00556   const T9 v9_;
00557   const T10 v10_;
00558   const T11 v11_;
00559   const T12 v12_;
00560   const T13 v13_;
00561   const T14 v14_;
00562   const T15 v15_;
00563   const T16 v16_;
00564 };
00565 
00566 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00567     typename T6, typename T7, typename T8, typename T9, typename T10,
00568     typename T11, typename T12, typename T13, typename T14, typename T15,
00569     typename T16, typename T17>
00570 class ValueArray17 {
00571  public:
00572   ValueArray17(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00573       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
00574       T17 v17) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
00575       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
00576       v15_(v15), v16_(v16), v17_(v17) {}
00577 
00578   template <typename T>
00579   operator ParamGenerator<T>() const {
00580     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00581         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00582         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00583         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
00584         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
00585         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_)};
00586     return ValuesIn(array);
00587   }
00588 
00589  private:
00590   // No implementation - assignment is unsupported.
00591   void operator=(const ValueArray17& other);
00592 
00593   const T1 v1_;
00594   const T2 v2_;
00595   const T3 v3_;
00596   const T4 v4_;
00597   const T5 v5_;
00598   const T6 v6_;
00599   const T7 v7_;
00600   const T8 v8_;
00601   const T9 v9_;
00602   const T10 v10_;
00603   const T11 v11_;
00604   const T12 v12_;
00605   const T13 v13_;
00606   const T14 v14_;
00607   const T15 v15_;
00608   const T16 v16_;
00609   const T17 v17_;
00610 };
00611 
00612 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00613     typename T6, typename T7, typename T8, typename T9, typename T10,
00614     typename T11, typename T12, typename T13, typename T14, typename T15,
00615     typename T16, typename T17, typename T18>
00616 class ValueArray18 {
00617  public:
00618   ValueArray18(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00619       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
00620       T18 v18) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
00621       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
00622       v15_(v15), v16_(v16), v17_(v17), v18_(v18) {}
00623 
00624   template <typename T>
00625   operator ParamGenerator<T>() const {
00626     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00627         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00628         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00629         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
00630         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
00631         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
00632         static_cast<T>(v18_)};
00633     return ValuesIn(array);
00634   }
00635 
00636  private:
00637   // No implementation - assignment is unsupported.
00638   void operator=(const ValueArray18& other);
00639 
00640   const T1 v1_;
00641   const T2 v2_;
00642   const T3 v3_;
00643   const T4 v4_;
00644   const T5 v5_;
00645   const T6 v6_;
00646   const T7 v7_;
00647   const T8 v8_;
00648   const T9 v9_;
00649   const T10 v10_;
00650   const T11 v11_;
00651   const T12 v12_;
00652   const T13 v13_;
00653   const T14 v14_;
00654   const T15 v15_;
00655   const T16 v16_;
00656   const T17 v17_;
00657   const T18 v18_;
00658 };
00659 
00660 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00661     typename T6, typename T7, typename T8, typename T9, typename T10,
00662     typename T11, typename T12, typename T13, typename T14, typename T15,
00663     typename T16, typename T17, typename T18, typename T19>
00664 class ValueArray19 {
00665  public:
00666   ValueArray19(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00667       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
00668       T18 v18, T19 v19) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
00669       v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
00670       v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19) {}
00671 
00672   template <typename T>
00673   operator ParamGenerator<T>() const {
00674     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00675         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00676         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00677         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
00678         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
00679         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
00680         static_cast<T>(v18_), static_cast<T>(v19_)};
00681     return ValuesIn(array);
00682   }
00683 
00684  private:
00685   // No implementation - assignment is unsupported.
00686   void operator=(const ValueArray19& other);
00687 
00688   const T1 v1_;
00689   const T2 v2_;
00690   const T3 v3_;
00691   const T4 v4_;
00692   const T5 v5_;
00693   const T6 v6_;
00694   const T7 v7_;
00695   const T8 v8_;
00696   const T9 v9_;
00697   const T10 v10_;
00698   const T11 v11_;
00699   const T12 v12_;
00700   const T13 v13_;
00701   const T14 v14_;
00702   const T15 v15_;
00703   const T16 v16_;
00704   const T17 v17_;
00705   const T18 v18_;
00706   const T19 v19_;
00707 };
00708 
00709 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00710     typename T6, typename T7, typename T8, typename T9, typename T10,
00711     typename T11, typename T12, typename T13, typename T14, typename T15,
00712     typename T16, typename T17, typename T18, typename T19, typename T20>
00713 class ValueArray20 {
00714  public:
00715   ValueArray20(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00716       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
00717       T18 v18, T19 v19, T20 v20) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
00718       v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
00719       v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
00720       v19_(v19), v20_(v20) {}
00721 
00722   template <typename T>
00723   operator ParamGenerator<T>() const {
00724     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00725         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00726         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00727         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
00728         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
00729         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
00730         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_)};
00731     return ValuesIn(array);
00732   }
00733 
00734  private:
00735   // No implementation - assignment is unsupported.
00736   void operator=(const ValueArray20& other);
00737 
00738   const T1 v1_;
00739   const T2 v2_;
00740   const T3 v3_;
00741   const T4 v4_;
00742   const T5 v5_;
00743   const T6 v6_;
00744   const T7 v7_;
00745   const T8 v8_;
00746   const T9 v9_;
00747   const T10 v10_;
00748   const T11 v11_;
00749   const T12 v12_;
00750   const T13 v13_;
00751   const T14 v14_;
00752   const T15 v15_;
00753   const T16 v16_;
00754   const T17 v17_;
00755   const T18 v18_;
00756   const T19 v19_;
00757   const T20 v20_;
00758 };
00759 
00760 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00761     typename T6, typename T7, typename T8, typename T9, typename T10,
00762     typename T11, typename T12, typename T13, typename T14, typename T15,
00763     typename T16, typename T17, typename T18, typename T19, typename T20,
00764     typename T21>
00765 class ValueArray21 {
00766  public:
00767   ValueArray21(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00768       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
00769       T18 v18, T19 v19, T20 v20, T21 v21) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
00770       v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
00771       v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
00772       v18_(v18), v19_(v19), v20_(v20), v21_(v21) {}
00773 
00774   template <typename T>
00775   operator ParamGenerator<T>() const {
00776     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00777         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00778         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00779         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
00780         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
00781         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
00782         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
00783         static_cast<T>(v21_)};
00784     return ValuesIn(array);
00785   }
00786 
00787  private:
00788   // No implementation - assignment is unsupported.
00789   void operator=(const ValueArray21& other);
00790 
00791   const T1 v1_;
00792   const T2 v2_;
00793   const T3 v3_;
00794   const T4 v4_;
00795   const T5 v5_;
00796   const T6 v6_;
00797   const T7 v7_;
00798   const T8 v8_;
00799   const T9 v9_;
00800   const T10 v10_;
00801   const T11 v11_;
00802   const T12 v12_;
00803   const T13 v13_;
00804   const T14 v14_;
00805   const T15 v15_;
00806   const T16 v16_;
00807   const T17 v17_;
00808   const T18 v18_;
00809   const T19 v19_;
00810   const T20 v20_;
00811   const T21 v21_;
00812 };
00813 
00814 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00815     typename T6, typename T7, typename T8, typename T9, typename T10,
00816     typename T11, typename T12, typename T13, typename T14, typename T15,
00817     typename T16, typename T17, typename T18, typename T19, typename T20,
00818     typename T21, typename T22>
00819 class ValueArray22 {
00820  public:
00821   ValueArray22(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00822       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
00823       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22) : v1_(v1), v2_(v2), v3_(v3),
00824       v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
00825       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
00826       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22) {}
00827 
00828   template <typename T>
00829   operator ParamGenerator<T>() const {
00830     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00831         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00832         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00833         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
00834         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
00835         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
00836         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
00837         static_cast<T>(v21_), static_cast<T>(v22_)};
00838     return ValuesIn(array);
00839   }
00840 
00841  private:
00842   // No implementation - assignment is unsupported.
00843   void operator=(const ValueArray22& other);
00844 
00845   const T1 v1_;
00846   const T2 v2_;
00847   const T3 v3_;
00848   const T4 v4_;
00849   const T5 v5_;
00850   const T6 v6_;
00851   const T7 v7_;
00852   const T8 v8_;
00853   const T9 v9_;
00854   const T10 v10_;
00855   const T11 v11_;
00856   const T12 v12_;
00857   const T13 v13_;
00858   const T14 v14_;
00859   const T15 v15_;
00860   const T16 v16_;
00861   const T17 v17_;
00862   const T18 v18_;
00863   const T19 v19_;
00864   const T20 v20_;
00865   const T21 v21_;
00866   const T22 v22_;
00867 };
00868 
00869 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00870     typename T6, typename T7, typename T8, typename T9, typename T10,
00871     typename T11, typename T12, typename T13, typename T14, typename T15,
00872     typename T16, typename T17, typename T18, typename T19, typename T20,
00873     typename T21, typename T22, typename T23>
00874 class ValueArray23 {
00875  public:
00876   ValueArray23(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00877       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
00878       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23) : v1_(v1), v2_(v2),
00879       v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
00880       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
00881       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
00882       v23_(v23) {}
00883 
00884   template <typename T>
00885   operator ParamGenerator<T>() const {
00886     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00887         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00888         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00889         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
00890         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
00891         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
00892         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
00893         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_)};
00894     return ValuesIn(array);
00895   }
00896 
00897  private:
00898   // No implementation - assignment is unsupported.
00899   void operator=(const ValueArray23& other);
00900 
00901   const T1 v1_;
00902   const T2 v2_;
00903   const T3 v3_;
00904   const T4 v4_;
00905   const T5 v5_;
00906   const T6 v6_;
00907   const T7 v7_;
00908   const T8 v8_;
00909   const T9 v9_;
00910   const T10 v10_;
00911   const T11 v11_;
00912   const T12 v12_;
00913   const T13 v13_;
00914   const T14 v14_;
00915   const T15 v15_;
00916   const T16 v16_;
00917   const T17 v17_;
00918   const T18 v18_;
00919   const T19 v19_;
00920   const T20 v20_;
00921   const T21 v21_;
00922   const T22 v22_;
00923   const T23 v23_;
00924 };
00925 
00926 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00927     typename T6, typename T7, typename T8, typename T9, typename T10,
00928     typename T11, typename T12, typename T13, typename T14, typename T15,
00929     typename T16, typename T17, typename T18, typename T19, typename T20,
00930     typename T21, typename T22, typename T23, typename T24>
00931 class ValueArray24 {
00932  public:
00933   ValueArray24(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00934       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
00935       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24) : v1_(v1),
00936       v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
00937       v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
00938       v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
00939       v22_(v22), v23_(v23), v24_(v24) {}
00940 
00941   template <typename T>
00942   operator ParamGenerator<T>() const {
00943     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
00944         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
00945         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
00946         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
00947         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
00948         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
00949         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
00950         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
00951         static_cast<T>(v24_)};
00952     return ValuesIn(array);
00953   }
00954 
00955  private:
00956   // No implementation - assignment is unsupported.
00957   void operator=(const ValueArray24& other);
00958 
00959   const T1 v1_;
00960   const T2 v2_;
00961   const T3 v3_;
00962   const T4 v4_;
00963   const T5 v5_;
00964   const T6 v6_;
00965   const T7 v7_;
00966   const T8 v8_;
00967   const T9 v9_;
00968   const T10 v10_;
00969   const T11 v11_;
00970   const T12 v12_;
00971   const T13 v13_;
00972   const T14 v14_;
00973   const T15 v15_;
00974   const T16 v16_;
00975   const T17 v17_;
00976   const T18 v18_;
00977   const T19 v19_;
00978   const T20 v20_;
00979   const T21 v21_;
00980   const T22 v22_;
00981   const T23 v23_;
00982   const T24 v24_;
00983 };
00984 
00985 template <typename T1, typename T2, typename T3, typename T4, typename T5,
00986     typename T6, typename T7, typename T8, typename T9, typename T10,
00987     typename T11, typename T12, typename T13, typename T14, typename T15,
00988     typename T16, typename T17, typename T18, typename T19, typename T20,
00989     typename T21, typename T22, typename T23, typename T24, typename T25>
00990 class ValueArray25 {
00991  public:
00992   ValueArray25(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
00993       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
00994       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
00995       T25 v25) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
00996       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
00997       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
00998       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25) {}
00999 
01000   template <typename T>
01001   operator ParamGenerator<T>() const {
01002     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
01003         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
01004         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
01005         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
01006         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
01007         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
01008         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
01009         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
01010         static_cast<T>(v24_), static_cast<T>(v25_)};
01011     return ValuesIn(array);
01012   }
01013 
01014  private:
01015   // No implementation - assignment is unsupported.
01016   void operator=(const ValueArray25& other);
01017 
01018   const T1 v1_;
01019   const T2 v2_;
01020   const T3 v3_;
01021   const T4 v4_;
01022   const T5 v5_;
01023   const T6 v6_;
01024   const T7 v7_;
01025   const T8 v8_;
01026   const T9 v9_;
01027   const T10 v10_;
01028   const T11 v11_;
01029   const T12 v12_;
01030   const T13 v13_;
01031   const T14 v14_;
01032   const T15 v15_;
01033   const T16 v16_;
01034   const T17 v17_;
01035   const T18 v18_;
01036   const T19 v19_;
01037   const T20 v20_;
01038   const T21 v21_;
01039   const T22 v22_;
01040   const T23 v23_;
01041   const T24 v24_;
01042   const T25 v25_;
01043 };
01044 
01045 template <typename T1, typename T2, typename T3, typename T4, typename T5,
01046     typename T6, typename T7, typename T8, typename T9, typename T10,
01047     typename T11, typename T12, typename T13, typename T14, typename T15,
01048     typename T16, typename T17, typename T18, typename T19, typename T20,
01049     typename T21, typename T22, typename T23, typename T24, typename T25,
01050     typename T26>
01051 class ValueArray26 {
01052  public:
01053   ValueArray26(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
01054       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
01055       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
01056       T26 v26) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
01057       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
01058       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
01059       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26) {}
01060 
01061   template <typename T>
01062   operator ParamGenerator<T>() const {
01063     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
01064         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
01065         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
01066         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
01067         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
01068         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
01069         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
01070         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
01071         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_)};
01072     return ValuesIn(array);
01073   }
01074 
01075  private:
01076   // No implementation - assignment is unsupported.
01077   void operator=(const ValueArray26& other);
01078 
01079   const T1 v1_;
01080   const T2 v2_;
01081   const T3 v3_;
01082   const T4 v4_;
01083   const T5 v5_;
01084   const T6 v6_;
01085   const T7 v7_;
01086   const T8 v8_;
01087   const T9 v9_;
01088   const T10 v10_;
01089   const T11 v11_;
01090   const T12 v12_;
01091   const T13 v13_;
01092   const T14 v14_;
01093   const T15 v15_;
01094   const T16 v16_;
01095   const T17 v17_;
01096   const T18 v18_;
01097   const T19 v19_;
01098   const T20 v20_;
01099   const T21 v21_;
01100   const T22 v22_;
01101   const T23 v23_;
01102   const T24 v24_;
01103   const T25 v25_;
01104   const T26 v26_;
01105 };
01106 
01107 template <typename T1, typename T2, typename T3, typename T4, typename T5,
01108     typename T6, typename T7, typename T8, typename T9, typename T10,
01109     typename T11, typename T12, typename T13, typename T14, typename T15,
01110     typename T16, typename T17, typename T18, typename T19, typename T20,
01111     typename T21, typename T22, typename T23, typename T24, typename T25,
01112     typename T26, typename T27>
01113 class ValueArray27 {
01114  public:
01115   ValueArray27(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
01116       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
01117       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
01118       T26 v26, T27 v27) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
01119       v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
01120       v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
01121       v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
01122       v26_(v26), v27_(v27) {}
01123 
01124   template <typename T>
01125   operator ParamGenerator<T>() const {
01126     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
01127         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
01128         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
01129         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
01130         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
01131         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
01132         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
01133         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
01134         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
01135         static_cast<T>(v27_)};
01136     return ValuesIn(array);
01137   }
01138 
01139  private:
01140   // No implementation - assignment is unsupported.
01141   void operator=(const ValueArray27& other);
01142 
01143   const T1 v1_;
01144   const T2 v2_;
01145   const T3 v3_;
01146   const T4 v4_;
01147   const T5 v5_;
01148   const T6 v6_;
01149   const T7 v7_;
01150   const T8 v8_;
01151   const T9 v9_;
01152   const T10 v10_;
01153   const T11 v11_;
01154   const T12 v12_;
01155   const T13 v13_;
01156   const T14 v14_;
01157   const T15 v15_;
01158   const T16 v16_;
01159   const T17 v17_;
01160   const T18 v18_;
01161   const T19 v19_;
01162   const T20 v20_;
01163   const T21 v21_;
01164   const T22 v22_;
01165   const T23 v23_;
01166   const T24 v24_;
01167   const T25 v25_;
01168   const T26 v26_;
01169   const T27 v27_;
01170 };
01171 
01172 template <typename T1, typename T2, typename T3, typename T4, typename T5,
01173     typename T6, typename T7, typename T8, typename T9, typename T10,
01174     typename T11, typename T12, typename T13, typename T14, typename T15,
01175     typename T16, typename T17, typename T18, typename T19, typename T20,
01176     typename T21, typename T22, typename T23, typename T24, typename T25,
01177     typename T26, typename T27, typename T28>
01178 class ValueArray28 {
01179  public:
01180   ValueArray28(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
01181       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
01182       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
01183       T26 v26, T27 v27, T28 v28) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
01184       v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
01185       v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
01186       v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
01187       v25_(v25), v26_(v26), v27_(v27), v28_(v28) {}
01188 
01189   template <typename T>
01190   operator ParamGenerator<T>() const {
01191     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
01192         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
01193         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
01194         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
01195         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
01196         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
01197         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
01198         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
01199         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
01200         static_cast<T>(v27_), static_cast<T>(v28_)};
01201     return ValuesIn(array);
01202   }
01203 
01204  private:
01205   // No implementation - assignment is unsupported.
01206   void operator=(const ValueArray28& other);
01207 
01208   const T1 v1_;
01209   const T2 v2_;
01210   const T3 v3_;
01211   const T4 v4_;
01212   const T5 v5_;
01213   const T6 v6_;
01214   const T7 v7_;
01215   const T8 v8_;
01216   const T9 v9_;
01217   const T10 v10_;
01218   const T11 v11_;
01219   const T12 v12_;
01220   const T13 v13_;
01221   const T14 v14_;
01222   const T15 v15_;
01223   const T16 v16_;
01224   const T17 v17_;
01225   const T18 v18_;
01226   const T19 v19_;
01227   const T20 v20_;
01228   const T21 v21_;
01229   const T22 v22_;
01230   const T23 v23_;
01231   const T24 v24_;
01232   const T25 v25_;
01233   const T26 v26_;
01234   const T27 v27_;
01235   const T28 v28_;
01236 };
01237 
01238 template <typename T1, typename T2, typename T3, typename T4, typename T5,
01239     typename T6, typename T7, typename T8, typename T9, typename T10,
01240     typename T11, typename T12, typename T13, typename T14, typename T15,
01241     typename T16, typename T17, typename T18, typename T19, typename T20,
01242     typename T21, typename T22, typename T23, typename T24, typename T25,
01243     typename T26, typename T27, typename T28, typename T29>
01244 class ValueArray29 {
01245  public:
01246   ValueArray29(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
01247       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
01248       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
01249       T26 v26, T27 v27, T28 v28, T29 v29) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
01250       v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
01251       v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
01252       v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
01253       v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29) {}
01254 
01255   template <typename T>
01256   operator ParamGenerator<T>() const {
01257     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
01258         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
01259         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
01260         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
01261         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
01262         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
01263         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
01264         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
01265         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
01266         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_)};
01267     return ValuesIn(array);
01268   }
01269 
01270  private:
01271   // No implementation - assignment is unsupported.
01272   void operator=(const ValueArray29& other);
01273 
01274   const T1 v1_;
01275   const T2 v2_;
01276   const T3 v3_;
01277   const T4 v4_;
01278   const T5 v5_;
01279   const T6 v6_;
01280   const T7 v7_;
01281   const T8 v8_;
01282   const T9 v9_;
01283   const T10 v10_;
01284   const T11 v11_;
01285   const T12 v12_;
01286   const T13 v13_;
01287   const T14 v14_;
01288   const T15 v15_;
01289   const T16 v16_;
01290   const T17 v17_;
01291   const T18 v18_;
01292   const T19 v19_;
01293   const T20 v20_;
01294   const T21 v21_;
01295   const T22 v22_;
01296   const T23 v23_;
01297   const T24 v24_;
01298   const T25 v25_;
01299   const T26 v26_;
01300   const T27 v27_;
01301   const T28 v28_;
01302   const T29 v29_;
01303 };
01304 
01305 template <typename T1, typename T2, typename T3, typename T4, typename T5,
01306     typename T6, typename T7, typename T8, typename T9, typename T10,
01307     typename T11, typename T12, typename T13, typename T14, typename T15,
01308     typename T16, typename T17, typename T18, typename T19, typename T20,
01309     typename T21, typename T22, typename T23, typename T24, typename T25,
01310     typename T26, typename T27, typename T28, typename T29, typename T30>
01311 class ValueArray30 {
01312  public:
01313   ValueArray30(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
01314       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
01315       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
01316       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) : v1_(v1), v2_(v2), v3_(v3),
01317       v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
01318       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
01319       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
01320       v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
01321       v29_(v29), v30_(v30) {}
01322 
01323   template <typename T>
01324   operator ParamGenerator<T>() const {
01325     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
01326         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
01327         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
01328         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
01329         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
01330         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
01331         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
01332         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
01333         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
01334         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
01335         static_cast<T>(v30_)};
01336     return ValuesIn(array);
01337   }
01338 
01339  private:
01340   // No implementation - assignment is unsupported.
01341   void operator=(const ValueArray30& other);
01342 
01343   const T1 v1_;
01344   const T2 v2_;
01345   const T3 v3_;
01346   const T4 v4_;
01347   const T5 v5_;
01348   const T6 v6_;
01349   const T7 v7_;
01350   const T8 v8_;
01351   const T9 v9_;
01352   const T10 v10_;
01353   const T11 v11_;
01354   const T12 v12_;
01355   const T13 v13_;
01356   const T14 v14_;
01357   const T15 v15_;
01358   const T16 v16_;
01359   const T17 v17_;
01360   const T18 v18_;
01361   const T19 v19_;
01362   const T20 v20_;
01363   const T21 v21_;
01364   const T22 v22_;
01365   const T23 v23_;
01366   const T24 v24_;
01367   const T25 v25_;
01368   const T26 v26_;
01369   const T27 v27_;
01370   const T28 v28_;
01371   const T29 v29_;
01372   const T30 v30_;
01373 };
01374 
01375 template <typename T1, typename T2, typename T3, typename T4, typename T5,
01376     typename T6, typename T7, typename T8, typename T9, typename T10,
01377     typename T11, typename T12, typename T13, typename T14, typename T15,
01378     typename T16, typename T17, typename T18, typename T19, typename T20,
01379     typename T21, typename T22, typename T23, typename T24, typename T25,
01380     typename T26, typename T27, typename T28, typename T29, typename T30,
01381     typename T31>
01382 class ValueArray31 {
01383  public:
01384   ValueArray31(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
01385       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
01386       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
01387       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) : v1_(v1), v2_(v2),
01388       v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
01389       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
01390       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
01391       v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
01392       v29_(v29), v30_(v30), v31_(v31) {}
01393 
01394   template <typename T>
01395   operator ParamGenerator<T>() const {
01396     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
01397         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
01398         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
01399         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
01400         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
01401         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
01402         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
01403         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
01404         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
01405         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
01406         static_cast<T>(v30_), static_cast<T>(v31_)};
01407     return ValuesIn(array);
01408   }
01409 
01410  private:
01411   // No implementation - assignment is unsupported.
01412   void operator=(const ValueArray31& other);
01413 
01414   const T1 v1_;
01415   const T2 v2_;
01416   const T3 v3_;
01417   const T4 v4_;
01418   const T5 v5_;
01419   const T6 v6_;
01420   const T7 v7_;
01421   const T8 v8_;
01422   const T9 v9_;
01423   const T10 v10_;
01424   const T11 v11_;
01425   const T12 v12_;
01426   const T13 v13_;
01427   const T14 v14_;
01428   const T15 v15_;
01429   const T16 v16_;
01430   const T17 v17_;
01431   const T18 v18_;
01432   const T19 v19_;
01433   const T20 v20_;
01434   const T21 v21_;
01435   const T22 v22_;
01436   const T23 v23_;
01437   const T24 v24_;
01438   const T25 v25_;
01439   const T26 v26_;
01440   const T27 v27_;
01441   const T28 v28_;
01442   const T29 v29_;
01443   const T30 v30_;
01444   const T31 v31_;
01445 };
01446 
01447 template <typename T1, typename T2, typename T3, typename T4, typename T5,
01448     typename T6, typename T7, typename T8, typename T9, typename T10,
01449     typename T11, typename T12, typename T13, typename T14, typename T15,
01450     typename T16, typename T17, typename T18, typename T19, typename T20,
01451     typename T21, typename T22, typename T23, typename T24, typename T25,
01452     typename T26, typename T27, typename T28, typename T29, typename T30,
01453     typename T31, typename T32>
01454 class ValueArray32 {
01455  public:
01456   ValueArray32(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
01457       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
01458       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
01459       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32) : v1_(v1),
01460       v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
01461       v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
01462       v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
01463       v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
01464       v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32) {}
01465 
01466   template <typename T>
01467   operator ParamGenerator<T>() const {
01468     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
01469         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
01470         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
01471         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
01472         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
01473         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
01474         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
01475         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
01476         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
01477         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
01478         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_)};
01479     return ValuesIn(array);
01480   }
01481 
01482  private:
01483   // No implementation - assignment is unsupported.
01484   void operator=(const ValueArray32& other);
01485 
01486   const T1 v1_;
01487   const T2 v2_;
01488   const T3 v3_;
01489   const T4 v4_;
01490   const T5 v5_;
01491   const T6 v6_;
01492   const T7 v7_;
01493   const T8 v8_;
01494   const T9 v9_;
01495   const T10 v10_;
01496   const T11 v11_;
01497   const T12 v12_;
01498   const T13 v13_;
01499   const T14 v14_;
01500   const T15 v15_;
01501   const T16 v16_;
01502   const T17 v17_;
01503   const T18 v18_;
01504   const T19 v19_;
01505   const T20 v20_;
01506   const T21 v21_;
01507   const T22 v22_;
01508   const T23 v23_;
01509   const T24 v24_;
01510   const T25 v25_;
01511   const T26 v26_;
01512   const T27 v27_;
01513   const T28 v28_;
01514   const T29 v29_;
01515   const T30 v30_;
01516   const T31 v31_;
01517   const T32 v32_;
01518 };
01519 
01520 template <typename T1, typename T2, typename T3, typename T4, typename T5,
01521     typename T6, typename T7, typename T8, typename T9, typename T10,
01522     typename T11, typename T12, typename T13, typename T14, typename T15,
01523     typename T16, typename T17, typename T18, typename T19, typename T20,
01524     typename T21, typename T22, typename T23, typename T24, typename T25,
01525     typename T26, typename T27, typename T28, typename T29, typename T30,
01526     typename T31, typename T32, typename T33>
01527 class ValueArray33 {
01528  public:
01529   ValueArray33(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
01530       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
01531       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
01532       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32,
01533       T33 v33) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
01534       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
01535       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
01536       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
01537       v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
01538       v33_(v33) {}
01539 
01540   template <typename T>
01541   operator ParamGenerator<T>() const {
01542     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
01543         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
01544         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
01545         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
01546         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
01547         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
01548         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
01549         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
01550         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
01551         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
01552         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
01553         static_cast<T>(v33_)};
01554     return ValuesIn(array);
01555   }
01556 
01557  private:
01558   // No implementation - assignment is unsupported.
01559   void operator=(const ValueArray33& other);
01560 
01561   const T1 v1_;
01562   const T2 v2_;
01563   const T3 v3_;
01564   const T4 v4_;
01565   const T5 v5_;
01566   const T6 v6_;
01567   const T7 v7_;
01568   const T8 v8_;
01569   const T9 v9_;
01570   const T10 v10_;
01571   const T11 v11_;
01572   const T12 v12_;
01573   const T13 v13_;
01574   const T14 v14_;
01575   const T15 v15_;
01576   const T16 v16_;
01577   const T17 v17_;
01578   const T18 v18_;
01579   const T19 v19_;
01580   const T20 v20_;
01581   const T21 v21_;
01582   const T22 v22_;
01583   const T23 v23_;
01584   const T24 v24_;
01585   const T25 v25_;
01586   const T26 v26_;
01587   const T27 v27_;
01588   const T28 v28_;
01589   const T29 v29_;
01590   const T30 v30_;
01591   const T31 v31_;
01592   const T32 v32_;
01593   const T33 v33_;
01594 };
01595 
01596 template <typename T1, typename T2, typename T3, typename T4, typename T5,
01597     typename T6, typename T7, typename T8, typename T9, typename T10,
01598     typename T11, typename T12, typename T13, typename T14, typename T15,
01599     typename T16, typename T17, typename T18, typename T19, typename T20,
01600     typename T21, typename T22, typename T23, typename T24, typename T25,
01601     typename T26, typename T27, typename T28, typename T29, typename T30,
01602     typename T31, typename T32, typename T33, typename T34>
01603 class ValueArray34 {
01604  public:
01605   ValueArray34(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
01606       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
01607       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
01608       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
01609       T34 v34) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
01610       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
01611       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
01612       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
01613       v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
01614       v33_(v33), v34_(v34) {}
01615 
01616   template <typename T>
01617   operator ParamGenerator<T>() const {
01618     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
01619         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
01620         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
01621         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
01622         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
01623         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
01624         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
01625         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
01626         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
01627         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
01628         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
01629         static_cast<T>(v33_), static_cast<T>(v34_)};
01630     return ValuesIn(array);
01631   }
01632 
01633  private:
01634   // No implementation - assignment is unsupported.
01635   void operator=(const ValueArray34& other);
01636 
01637   const T1 v1_;
01638   const T2 v2_;
01639   const T3 v3_;
01640   const T4 v4_;
01641   const T5 v5_;
01642   const T6 v6_;
01643   const T7 v7_;
01644   const T8 v8_;
01645   const T9 v9_;
01646   const T10 v10_;
01647   const T11 v11_;
01648   const T12 v12_;
01649   const T13 v13_;
01650   const T14 v14_;
01651   const T15 v15_;
01652   const T16 v16_;
01653   const T17 v17_;
01654   const T18 v18_;
01655   const T19 v19_;
01656   const T20 v20_;
01657   const T21 v21_;
01658   const T22 v22_;
01659   const T23 v23_;
01660   const T24 v24_;
01661   const T25 v25_;
01662   const T26 v26_;
01663   const T27 v27_;
01664   const T28 v28_;
01665   const T29 v29_;
01666   const T30 v30_;
01667   const T31 v31_;
01668   const T32 v32_;
01669   const T33 v33_;
01670   const T34 v34_;
01671 };
01672 
01673 template <typename T1, typename T2, typename T3, typename T4, typename T5,
01674     typename T6, typename T7, typename T8, typename T9, typename T10,
01675     typename T11, typename T12, typename T13, typename T14, typename T15,
01676     typename T16, typename T17, typename T18, typename T19, typename T20,
01677     typename T21, typename T22, typename T23, typename T24, typename T25,
01678     typename T26, typename T27, typename T28, typename T29, typename T30,
01679     typename T31, typename T32, typename T33, typename T34, typename T35>
01680 class ValueArray35 {
01681  public:
01682   ValueArray35(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
01683       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
01684       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
01685       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
01686       T34 v34, T35 v35) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
01687       v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
01688       v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
01689       v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
01690       v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
01691       v32_(v32), v33_(v33), v34_(v34), v35_(v35) {}
01692 
01693   template <typename T>
01694   operator ParamGenerator<T>() const {
01695     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
01696         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
01697         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
01698         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
01699         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
01700         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
01701         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
01702         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
01703         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
01704         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
01705         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
01706         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_)};
01707     return ValuesIn(array);
01708   }
01709 
01710  private:
01711   // No implementation - assignment is unsupported.
01712   void operator=(const ValueArray35& other);
01713 
01714   const T1 v1_;
01715   const T2 v2_;
01716   const T3 v3_;
01717   const T4 v4_;
01718   const T5 v5_;
01719   const T6 v6_;
01720   const T7 v7_;
01721   const T8 v8_;
01722   const T9 v9_;
01723   const T10 v10_;
01724   const T11 v11_;
01725   const T12 v12_;
01726   const T13 v13_;
01727   const T14 v14_;
01728   const T15 v15_;
01729   const T16 v16_;
01730   const T17 v17_;
01731   const T18 v18_;
01732   const T19 v19_;
01733   const T20 v20_;
01734   const T21 v21_;
01735   const T22 v22_;
01736   const T23 v23_;
01737   const T24 v24_;
01738   const T25 v25_;
01739   const T26 v26_;
01740   const T27 v27_;
01741   const T28 v28_;
01742   const T29 v29_;
01743   const T30 v30_;
01744   const T31 v31_;
01745   const T32 v32_;
01746   const T33 v33_;
01747   const T34 v34_;
01748   const T35 v35_;
01749 };
01750 
01751 template <typename T1, typename T2, typename T3, typename T4, typename T5,
01752     typename T6, typename T7, typename T8, typename T9, typename T10,
01753     typename T11, typename T12, typename T13, typename T14, typename T15,
01754     typename T16, typename T17, typename T18, typename T19, typename T20,
01755     typename T21, typename T22, typename T23, typename T24, typename T25,
01756     typename T26, typename T27, typename T28, typename T29, typename T30,
01757     typename T31, typename T32, typename T33, typename T34, typename T35,
01758     typename T36>
01759 class ValueArray36 {
01760  public:
01761   ValueArray36(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
01762       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
01763       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
01764       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
01765       T34 v34, T35 v35, T36 v36) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
01766       v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
01767       v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
01768       v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
01769       v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
01770       v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36) {}
01771 
01772   template <typename T>
01773   operator ParamGenerator<T>() const {
01774     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
01775         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
01776         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
01777         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
01778         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
01779         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
01780         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
01781         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
01782         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
01783         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
01784         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
01785         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
01786         static_cast<T>(v36_)};
01787     return ValuesIn(array);
01788   }
01789 
01790  private:
01791   // No implementation - assignment is unsupported.
01792   void operator=(const ValueArray36& other);
01793 
01794   const T1 v1_;
01795   const T2 v2_;
01796   const T3 v3_;
01797   const T4 v4_;
01798   const T5 v5_;
01799   const T6 v6_;
01800   const T7 v7_;
01801   const T8 v8_;
01802   const T9 v9_;
01803   const T10 v10_;
01804   const T11 v11_;
01805   const T12 v12_;
01806   const T13 v13_;
01807   const T14 v14_;
01808   const T15 v15_;
01809   const T16 v16_;
01810   const T17 v17_;
01811   const T18 v18_;
01812   const T19 v19_;
01813   const T20 v20_;
01814   const T21 v21_;
01815   const T22 v22_;
01816   const T23 v23_;
01817   const T24 v24_;
01818   const T25 v25_;
01819   const T26 v26_;
01820   const T27 v27_;
01821   const T28 v28_;
01822   const T29 v29_;
01823   const T30 v30_;
01824   const T31 v31_;
01825   const T32 v32_;
01826   const T33 v33_;
01827   const T34 v34_;
01828   const T35 v35_;
01829   const T36 v36_;
01830 };
01831 
01832 template <typename T1, typename T2, typename T3, typename T4, typename T5,
01833     typename T6, typename T7, typename T8, typename T9, typename T10,
01834     typename T11, typename T12, typename T13, typename T14, typename T15,
01835     typename T16, typename T17, typename T18, typename T19, typename T20,
01836     typename T21, typename T22, typename T23, typename T24, typename T25,
01837     typename T26, typename T27, typename T28, typename T29, typename T30,
01838     typename T31, typename T32, typename T33, typename T34, typename T35,
01839     typename T36, typename T37>
01840 class ValueArray37 {
01841  public:
01842   ValueArray37(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
01843       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
01844       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
01845       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
01846       T34 v34, T35 v35, T36 v36, T37 v37) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
01847       v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
01848       v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
01849       v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
01850       v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
01851       v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
01852       v36_(v36), v37_(v37) {}
01853 
01854   template <typename T>
01855   operator ParamGenerator<T>() const {
01856     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
01857         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
01858         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
01859         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
01860         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
01861         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
01862         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
01863         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
01864         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
01865         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
01866         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
01867         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
01868         static_cast<T>(v36_), static_cast<T>(v37_)};
01869     return ValuesIn(array);
01870   }
01871 
01872  private:
01873   // No implementation - assignment is unsupported.
01874   void operator=(const ValueArray37& other);
01875 
01876   const T1 v1_;
01877   const T2 v2_;
01878   const T3 v3_;
01879   const T4 v4_;
01880   const T5 v5_;
01881   const T6 v6_;
01882   const T7 v7_;
01883   const T8 v8_;
01884   const T9 v9_;
01885   const T10 v10_;
01886   const T11 v11_;
01887   const T12 v12_;
01888   const T13 v13_;
01889   const T14 v14_;
01890   const T15 v15_;
01891   const T16 v16_;
01892   const T17 v17_;
01893   const T18 v18_;
01894   const T19 v19_;
01895   const T20 v20_;
01896   const T21 v21_;
01897   const T22 v22_;
01898   const T23 v23_;
01899   const T24 v24_;
01900   const T25 v25_;
01901   const T26 v26_;
01902   const T27 v27_;
01903   const T28 v28_;
01904   const T29 v29_;
01905   const T30 v30_;
01906   const T31 v31_;
01907   const T32 v32_;
01908   const T33 v33_;
01909   const T34 v34_;
01910   const T35 v35_;
01911   const T36 v36_;
01912   const T37 v37_;
01913 };
01914 
01915 template <typename T1, typename T2, typename T3, typename T4, typename T5,
01916     typename T6, typename T7, typename T8, typename T9, typename T10,
01917     typename T11, typename T12, typename T13, typename T14, typename T15,
01918     typename T16, typename T17, typename T18, typename T19, typename T20,
01919     typename T21, typename T22, typename T23, typename T24, typename T25,
01920     typename T26, typename T27, typename T28, typename T29, typename T30,
01921     typename T31, typename T32, typename T33, typename T34, typename T35,
01922     typename T36, typename T37, typename T38>
01923 class ValueArray38 {
01924  public:
01925   ValueArray38(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
01926       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
01927       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
01928       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
01929       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38) : v1_(v1), v2_(v2), v3_(v3),
01930       v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
01931       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
01932       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
01933       v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
01934       v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
01935       v35_(v35), v36_(v36), v37_(v37), v38_(v38) {}
01936 
01937   template <typename T>
01938   operator ParamGenerator<T>() const {
01939     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
01940         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
01941         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
01942         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
01943         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
01944         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
01945         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
01946         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
01947         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
01948         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
01949         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
01950         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
01951         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_)};
01952     return ValuesIn(array);
01953   }
01954 
01955  private:
01956   // No implementation - assignment is unsupported.
01957   void operator=(const ValueArray38& other);
01958 
01959   const T1 v1_;
01960   const T2 v2_;
01961   const T3 v3_;
01962   const T4 v4_;
01963   const T5 v5_;
01964   const T6 v6_;
01965   const T7 v7_;
01966   const T8 v8_;
01967   const T9 v9_;
01968   const T10 v10_;
01969   const T11 v11_;
01970   const T12 v12_;
01971   const T13 v13_;
01972   const T14 v14_;
01973   const T15 v15_;
01974   const T16 v16_;
01975   const T17 v17_;
01976   const T18 v18_;
01977   const T19 v19_;
01978   const T20 v20_;
01979   const T21 v21_;
01980   const T22 v22_;
01981   const T23 v23_;
01982   const T24 v24_;
01983   const T25 v25_;
01984   const T26 v26_;
01985   const T27 v27_;
01986   const T28 v28_;
01987   const T29 v29_;
01988   const T30 v30_;
01989   const T31 v31_;
01990   const T32 v32_;
01991   const T33 v33_;
01992   const T34 v34_;
01993   const T35 v35_;
01994   const T36 v36_;
01995   const T37 v37_;
01996   const T38 v38_;
01997 };
01998 
01999 template <typename T1, typename T2, typename T3, typename T4, typename T5,
02000     typename T6, typename T7, typename T8, typename T9, typename T10,
02001     typename T11, typename T12, typename T13, typename T14, typename T15,
02002     typename T16, typename T17, typename T18, typename T19, typename T20,
02003     typename T21, typename T22, typename T23, typename T24, typename T25,
02004     typename T26, typename T27, typename T28, typename T29, typename T30,
02005     typename T31, typename T32, typename T33, typename T34, typename T35,
02006     typename T36, typename T37, typename T38, typename T39>
02007 class ValueArray39 {
02008  public:
02009   ValueArray39(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
02010       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
02011       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
02012       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
02013       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39) : v1_(v1), v2_(v2),
02014       v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
02015       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
02016       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
02017       v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
02018       v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
02019       v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39) {}
02020 
02021   template <typename T>
02022   operator ParamGenerator<T>() const {
02023     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
02024         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
02025         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
02026         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
02027         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
02028         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
02029         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
02030         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
02031         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
02032         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
02033         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
02034         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
02035         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
02036         static_cast<T>(v39_)};
02037     return ValuesIn(array);
02038   }
02039 
02040  private:
02041   // No implementation - assignment is unsupported.
02042   void operator=(const ValueArray39& other);
02043 
02044   const T1 v1_;
02045   const T2 v2_;
02046   const T3 v3_;
02047   const T4 v4_;
02048   const T5 v5_;
02049   const T6 v6_;
02050   const T7 v7_;
02051   const T8 v8_;
02052   const T9 v9_;
02053   const T10 v10_;
02054   const T11 v11_;
02055   const T12 v12_;
02056   const T13 v13_;
02057   const T14 v14_;
02058   const T15 v15_;
02059   const T16 v16_;
02060   const T17 v17_;
02061   const T18 v18_;
02062   const T19 v19_;
02063   const T20 v20_;
02064   const T21 v21_;
02065   const T22 v22_;
02066   const T23 v23_;
02067   const T24 v24_;
02068   const T25 v25_;
02069   const T26 v26_;
02070   const T27 v27_;
02071   const T28 v28_;
02072   const T29 v29_;
02073   const T30 v30_;
02074   const T31 v31_;
02075   const T32 v32_;
02076   const T33 v33_;
02077   const T34 v34_;
02078   const T35 v35_;
02079   const T36 v36_;
02080   const T37 v37_;
02081   const T38 v38_;
02082   const T39 v39_;
02083 };
02084 
02085 template <typename T1, typename T2, typename T3, typename T4, typename T5,
02086     typename T6, typename T7, typename T8, typename T9, typename T10,
02087     typename T11, typename T12, typename T13, typename T14, typename T15,
02088     typename T16, typename T17, typename T18, typename T19, typename T20,
02089     typename T21, typename T22, typename T23, typename T24, typename T25,
02090     typename T26, typename T27, typename T28, typename T29, typename T30,
02091     typename T31, typename T32, typename T33, typename T34, typename T35,
02092     typename T36, typename T37, typename T38, typename T39, typename T40>
02093 class ValueArray40 {
02094  public:
02095   ValueArray40(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
02096       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
02097       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
02098       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
02099       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) : v1_(v1),
02100       v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
02101       v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
02102       v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
02103       v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
02104       v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
02105       v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
02106       v40_(v40) {}
02107 
02108   template <typename T>
02109   operator ParamGenerator<T>() const {
02110     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
02111         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
02112         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
02113         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
02114         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
02115         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
02116         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
02117         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
02118         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
02119         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
02120         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
02121         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
02122         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
02123         static_cast<T>(v39_), static_cast<T>(v40_)};
02124     return ValuesIn(array);
02125   }
02126 
02127  private:
02128   // No implementation - assignment is unsupported.
02129   void operator=(const ValueArray40& other);
02130 
02131   const T1 v1_;
02132   const T2 v2_;
02133   const T3 v3_;
02134   const T4 v4_;
02135   const T5 v5_;
02136   const T6 v6_;
02137   const T7 v7_;
02138   const T8 v8_;
02139   const T9 v9_;
02140   const T10 v10_;
02141   const T11 v11_;
02142   const T12 v12_;
02143   const T13 v13_;
02144   const T14 v14_;
02145   const T15 v15_;
02146   const T16 v16_;
02147   const T17 v17_;
02148   const T18 v18_;
02149   const T19 v19_;
02150   const T20 v20_;
02151   const T21 v21_;
02152   const T22 v22_;
02153   const T23 v23_;
02154   const T24 v24_;
02155   const T25 v25_;
02156   const T26 v26_;
02157   const T27 v27_;
02158   const T28 v28_;
02159   const T29 v29_;
02160   const T30 v30_;
02161   const T31 v31_;
02162   const T32 v32_;
02163   const T33 v33_;
02164   const T34 v34_;
02165   const T35 v35_;
02166   const T36 v36_;
02167   const T37 v37_;
02168   const T38 v38_;
02169   const T39 v39_;
02170   const T40 v40_;
02171 };
02172 
02173 template <typename T1, typename T2, typename T3, typename T4, typename T5,
02174     typename T6, typename T7, typename T8, typename T9, typename T10,
02175     typename T11, typename T12, typename T13, typename T14, typename T15,
02176     typename T16, typename T17, typename T18, typename T19, typename T20,
02177     typename T21, typename T22, typename T23, typename T24, typename T25,
02178     typename T26, typename T27, typename T28, typename T29, typename T30,
02179     typename T31, typename T32, typename T33, typename T34, typename T35,
02180     typename T36, typename T37, typename T38, typename T39, typename T40,
02181     typename T41>
02182 class ValueArray41 {
02183  public:
02184   ValueArray41(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
02185       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
02186       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
02187       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
02188       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40,
02189       T41 v41) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
02190       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
02191       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
02192       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
02193       v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
02194       v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
02195       v39_(v39), v40_(v40), v41_(v41) {}
02196 
02197   template <typename T>
02198   operator ParamGenerator<T>() const {
02199     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
02200         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
02201         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
02202         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
02203         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
02204         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
02205         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
02206         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
02207         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
02208         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
02209         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
02210         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
02211         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
02212         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_)};
02213     return ValuesIn(array);
02214   }
02215 
02216  private:
02217   // No implementation - assignment is unsupported.
02218   void operator=(const ValueArray41& other);
02219 
02220   const T1 v1_;
02221   const T2 v2_;
02222   const T3 v3_;
02223   const T4 v4_;
02224   const T5 v5_;
02225   const T6 v6_;
02226   const T7 v7_;
02227   const T8 v8_;
02228   const T9 v9_;
02229   const T10 v10_;
02230   const T11 v11_;
02231   const T12 v12_;
02232   const T13 v13_;
02233   const T14 v14_;
02234   const T15 v15_;
02235   const T16 v16_;
02236   const T17 v17_;
02237   const T18 v18_;
02238   const T19 v19_;
02239   const T20 v20_;
02240   const T21 v21_;
02241   const T22 v22_;
02242   const T23 v23_;
02243   const T24 v24_;
02244   const T25 v25_;
02245   const T26 v26_;
02246   const T27 v27_;
02247   const T28 v28_;
02248   const T29 v29_;
02249   const T30 v30_;
02250   const T31 v31_;
02251   const T32 v32_;
02252   const T33 v33_;
02253   const T34 v34_;
02254   const T35 v35_;
02255   const T36 v36_;
02256   const T37 v37_;
02257   const T38 v38_;
02258   const T39 v39_;
02259   const T40 v40_;
02260   const T41 v41_;
02261 };
02262 
02263 template <typename T1, typename T2, typename T3, typename T4, typename T5,
02264     typename T6, typename T7, typename T8, typename T9, typename T10,
02265     typename T11, typename T12, typename T13, typename T14, typename T15,
02266     typename T16, typename T17, typename T18, typename T19, typename T20,
02267     typename T21, typename T22, typename T23, typename T24, typename T25,
02268     typename T26, typename T27, typename T28, typename T29, typename T30,
02269     typename T31, typename T32, typename T33, typename T34, typename T35,
02270     typename T36, typename T37, typename T38, typename T39, typename T40,
02271     typename T41, typename T42>
02272 class ValueArray42 {
02273  public:
02274   ValueArray42(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
02275       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
02276       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
02277       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
02278       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
02279       T42 v42) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
02280       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
02281       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
02282       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
02283       v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
02284       v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
02285       v39_(v39), v40_(v40), v41_(v41), v42_(v42) {}
02286 
02287   template <typename T>
02288   operator ParamGenerator<T>() const {
02289     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
02290         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
02291         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
02292         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
02293         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
02294         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
02295         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
02296         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
02297         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
02298         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
02299         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
02300         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
02301         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
02302         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
02303         static_cast<T>(v42_)};
02304     return ValuesIn(array);
02305   }
02306 
02307  private:
02308   // No implementation - assignment is unsupported.
02309   void operator=(const ValueArray42& other);
02310 
02311   const T1 v1_;
02312   const T2 v2_;
02313   const T3 v3_;
02314   const T4 v4_;
02315   const T5 v5_;
02316   const T6 v6_;
02317   const T7 v7_;
02318   const T8 v8_;
02319   const T9 v9_;
02320   const T10 v10_;
02321   const T11 v11_;
02322   const T12 v12_;
02323   const T13 v13_;
02324   const T14 v14_;
02325   const T15 v15_;
02326   const T16 v16_;
02327   const T17 v17_;
02328   const T18 v18_;
02329   const T19 v19_;
02330   const T20 v20_;
02331   const T21 v21_;
02332   const T22 v22_;
02333   const T23 v23_;
02334   const T24 v24_;
02335   const T25 v25_;
02336   const T26 v26_;
02337   const T27 v27_;
02338   const T28 v28_;
02339   const T29 v29_;
02340   const T30 v30_;
02341   const T31 v31_;
02342   const T32 v32_;
02343   const T33 v33_;
02344   const T34 v34_;
02345   const T35 v35_;
02346   const T36 v36_;
02347   const T37 v37_;
02348   const T38 v38_;
02349   const T39 v39_;
02350   const T40 v40_;
02351   const T41 v41_;
02352   const T42 v42_;
02353 };
02354 
02355 template <typename T1, typename T2, typename T3, typename T4, typename T5,
02356     typename T6, typename T7, typename T8, typename T9, typename T10,
02357     typename T11, typename T12, typename T13, typename T14, typename T15,
02358     typename T16, typename T17, typename T18, typename T19, typename T20,
02359     typename T21, typename T22, typename T23, typename T24, typename T25,
02360     typename T26, typename T27, typename T28, typename T29, typename T30,
02361     typename T31, typename T32, typename T33, typename T34, typename T35,
02362     typename T36, typename T37, typename T38, typename T39, typename T40,
02363     typename T41, typename T42, typename T43>
02364 class ValueArray43 {
02365  public:
02366   ValueArray43(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
02367       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
02368       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
02369       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
02370       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
02371       T42 v42, T43 v43) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
02372       v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
02373       v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
02374       v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
02375       v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
02376       v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37),
02377       v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43) {}
02378 
02379   template <typename T>
02380   operator ParamGenerator<T>() const {
02381     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
02382         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
02383         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
02384         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
02385         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
02386         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
02387         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
02388         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
02389         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
02390         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
02391         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
02392         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
02393         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
02394         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
02395         static_cast<T>(v42_), static_cast<T>(v43_)};
02396     return ValuesIn(array);
02397   }
02398 
02399  private:
02400   // No implementation - assignment is unsupported.
02401   void operator=(const ValueArray43& other);
02402 
02403   const T1 v1_;
02404   const T2 v2_;
02405   const T3 v3_;
02406   const T4 v4_;
02407   const T5 v5_;
02408   const T6 v6_;
02409   const T7 v7_;
02410   const T8 v8_;
02411   const T9 v9_;
02412   const T10 v10_;
02413   const T11 v11_;
02414   const T12 v12_;
02415   const T13 v13_;
02416   const T14 v14_;
02417   const T15 v15_;
02418   const T16 v16_;
02419   const T17 v17_;
02420   const T18 v18_;
02421   const T19 v19_;
02422   const T20 v20_;
02423   const T21 v21_;
02424   const T22 v22_;
02425   const T23 v23_;
02426   const T24 v24_;
02427   const T25 v25_;
02428   const T26 v26_;
02429   const T27 v27_;
02430   const T28 v28_;
02431   const T29 v29_;
02432   const T30 v30_;
02433   const T31 v31_;
02434   const T32 v32_;
02435   const T33 v33_;
02436   const T34 v34_;
02437   const T35 v35_;
02438   const T36 v36_;
02439   const T37 v37_;
02440   const T38 v38_;
02441   const T39 v39_;
02442   const T40 v40_;
02443   const T41 v41_;
02444   const T42 v42_;
02445   const T43 v43_;
02446 };
02447 
02448 template <typename T1, typename T2, typename T3, typename T4, typename T5,
02449     typename T6, typename T7, typename T8, typename T9, typename T10,
02450     typename T11, typename T12, typename T13, typename T14, typename T15,
02451     typename T16, typename T17, typename T18, typename T19, typename T20,
02452     typename T21, typename T22, typename T23, typename T24, typename T25,
02453     typename T26, typename T27, typename T28, typename T29, typename T30,
02454     typename T31, typename T32, typename T33, typename T34, typename T35,
02455     typename T36, typename T37, typename T38, typename T39, typename T40,
02456     typename T41, typename T42, typename T43, typename T44>
02457 class ValueArray44 {
02458  public:
02459   ValueArray44(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
02460       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
02461       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
02462       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
02463       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
02464       T42 v42, T43 v43, T44 v44) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
02465       v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
02466       v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
02467       v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
02468       v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
02469       v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36),
02470       v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42),
02471       v43_(v43), v44_(v44) {}
02472 
02473   template <typename T>
02474   operator ParamGenerator<T>() const {
02475     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
02476         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
02477         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
02478         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
02479         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
02480         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
02481         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
02482         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
02483         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
02484         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
02485         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
02486         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
02487         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
02488         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
02489         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_)};
02490     return ValuesIn(array);
02491   }
02492 
02493  private:
02494   // No implementation - assignment is unsupported.
02495   void operator=(const ValueArray44& other);
02496 
02497   const T1 v1_;
02498   const T2 v2_;
02499   const T3 v3_;
02500   const T4 v4_;
02501   const T5 v5_;
02502   const T6 v6_;
02503   const T7 v7_;
02504   const T8 v8_;
02505   const T9 v9_;
02506   const T10 v10_;
02507   const T11 v11_;
02508   const T12 v12_;
02509   const T13 v13_;
02510   const T14 v14_;
02511   const T15 v15_;
02512   const T16 v16_;
02513   const T17 v17_;
02514   const T18 v18_;
02515   const T19 v19_;
02516   const T20 v20_;
02517   const T21 v21_;
02518   const T22 v22_;
02519   const T23 v23_;
02520   const T24 v24_;
02521   const T25 v25_;
02522   const T26 v26_;
02523   const T27 v27_;
02524   const T28 v28_;
02525   const T29 v29_;
02526   const T30 v30_;
02527   const T31 v31_;
02528   const T32 v32_;
02529   const T33 v33_;
02530   const T34 v34_;
02531   const T35 v35_;
02532   const T36 v36_;
02533   const T37 v37_;
02534   const T38 v38_;
02535   const T39 v39_;
02536   const T40 v40_;
02537   const T41 v41_;
02538   const T42 v42_;
02539   const T43 v43_;
02540   const T44 v44_;
02541 };
02542 
02543 template <typename T1, typename T2, typename T3, typename T4, typename T5,
02544     typename T6, typename T7, typename T8, typename T9, typename T10,
02545     typename T11, typename T12, typename T13, typename T14, typename T15,
02546     typename T16, typename T17, typename T18, typename T19, typename T20,
02547     typename T21, typename T22, typename T23, typename T24, typename T25,
02548     typename T26, typename T27, typename T28, typename T29, typename T30,
02549     typename T31, typename T32, typename T33, typename T34, typename T35,
02550     typename T36, typename T37, typename T38, typename T39, typename T40,
02551     typename T41, typename T42, typename T43, typename T44, typename T45>
02552 class ValueArray45 {
02553  public:
02554   ValueArray45(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
02555       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
02556       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
02557       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
02558       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
02559       T42 v42, T43 v43, T44 v44, T45 v45) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
02560       v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
02561       v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
02562       v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
02563       v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
02564       v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
02565       v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41),
02566       v42_(v42), v43_(v43), v44_(v44), v45_(v45) {}
02567 
02568   template <typename T>
02569   operator ParamGenerator<T>() const {
02570     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
02571         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
02572         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
02573         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
02574         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
02575         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
02576         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
02577         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
02578         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
02579         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
02580         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
02581         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
02582         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
02583         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
02584         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
02585         static_cast<T>(v45_)};
02586     return ValuesIn(array);
02587   }
02588 
02589  private:
02590   // No implementation - assignment is unsupported.
02591   void operator=(const ValueArray45& other);
02592 
02593   const T1 v1_;
02594   const T2 v2_;
02595   const T3 v3_;
02596   const T4 v4_;
02597   const T5 v5_;
02598   const T6 v6_;
02599   const T7 v7_;
02600   const T8 v8_;
02601   const T9 v9_;
02602   const T10 v10_;
02603   const T11 v11_;
02604   const T12 v12_;
02605   const T13 v13_;
02606   const T14 v14_;
02607   const T15 v15_;
02608   const T16 v16_;
02609   const T17 v17_;
02610   const T18 v18_;
02611   const T19 v19_;
02612   const T20 v20_;
02613   const T21 v21_;
02614   const T22 v22_;
02615   const T23 v23_;
02616   const T24 v24_;
02617   const T25 v25_;
02618   const T26 v26_;
02619   const T27 v27_;
02620   const T28 v28_;
02621   const T29 v29_;
02622   const T30 v30_;
02623   const T31 v31_;
02624   const T32 v32_;
02625   const T33 v33_;
02626   const T34 v34_;
02627   const T35 v35_;
02628   const T36 v36_;
02629   const T37 v37_;
02630   const T38 v38_;
02631   const T39 v39_;
02632   const T40 v40_;
02633   const T41 v41_;
02634   const T42 v42_;
02635   const T43 v43_;
02636   const T44 v44_;
02637   const T45 v45_;
02638 };
02639 
02640 template <typename T1, typename T2, typename T3, typename T4, typename T5,
02641     typename T6, typename T7, typename T8, typename T9, typename T10,
02642     typename T11, typename T12, typename T13, typename T14, typename T15,
02643     typename T16, typename T17, typename T18, typename T19, typename T20,
02644     typename T21, typename T22, typename T23, typename T24, typename T25,
02645     typename T26, typename T27, typename T28, typename T29, typename T30,
02646     typename T31, typename T32, typename T33, typename T34, typename T35,
02647     typename T36, typename T37, typename T38, typename T39, typename T40,
02648     typename T41, typename T42, typename T43, typename T44, typename T45,
02649     typename T46>
02650 class ValueArray46 {
02651  public:
02652   ValueArray46(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
02653       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
02654       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
02655       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
02656       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
02657       T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) : v1_(v1), v2_(v2), v3_(v3),
02658       v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
02659       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
02660       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
02661       v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
02662       v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
02663       v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
02664       v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46) {}
02665 
02666   template <typename T>
02667   operator ParamGenerator<T>() const {
02668     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
02669         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
02670         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
02671         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
02672         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
02673         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
02674         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
02675         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
02676         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
02677         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
02678         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
02679         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
02680         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
02681         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
02682         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
02683         static_cast<T>(v45_), static_cast<T>(v46_)};
02684     return ValuesIn(array);
02685   }
02686 
02687  private:
02688   // No implementation - assignment is unsupported.
02689   void operator=(const ValueArray46& other);
02690 
02691   const T1 v1_;
02692   const T2 v2_;
02693   const T3 v3_;
02694   const T4 v4_;
02695   const T5 v5_;
02696   const T6 v6_;
02697   const T7 v7_;
02698   const T8 v8_;
02699   const T9 v9_;
02700   const T10 v10_;
02701   const T11 v11_;
02702   const T12 v12_;
02703   const T13 v13_;
02704   const T14 v14_;
02705   const T15 v15_;
02706   const T16 v16_;
02707   const T17 v17_;
02708   const T18 v18_;
02709   const T19 v19_;
02710   const T20 v20_;
02711   const T21 v21_;
02712   const T22 v22_;
02713   const T23 v23_;
02714   const T24 v24_;
02715   const T25 v25_;
02716   const T26 v26_;
02717   const T27 v27_;
02718   const T28 v28_;
02719   const T29 v29_;
02720   const T30 v30_;
02721   const T31 v31_;
02722   const T32 v32_;
02723   const T33 v33_;
02724   const T34 v34_;
02725   const T35 v35_;
02726   const T36 v36_;
02727   const T37 v37_;
02728   const T38 v38_;
02729   const T39 v39_;
02730   const T40 v40_;
02731   const T41 v41_;
02732   const T42 v42_;
02733   const T43 v43_;
02734   const T44 v44_;
02735   const T45 v45_;
02736   const T46 v46_;
02737 };
02738 
02739 template <typename T1, typename T2, typename T3, typename T4, typename T5,
02740     typename T6, typename T7, typename T8, typename T9, typename T10,
02741     typename T11, typename T12, typename T13, typename T14, typename T15,
02742     typename T16, typename T17, typename T18, typename T19, typename T20,
02743     typename T21, typename T22, typename T23, typename T24, typename T25,
02744     typename T26, typename T27, typename T28, typename T29, typename T30,
02745     typename T31, typename T32, typename T33, typename T34, typename T35,
02746     typename T36, typename T37, typename T38, typename T39, typename T40,
02747     typename T41, typename T42, typename T43, typename T44, typename T45,
02748     typename T46, typename T47>
02749 class ValueArray47 {
02750  public:
02751   ValueArray47(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
02752       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
02753       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
02754       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
02755       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
02756       T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) : v1_(v1), v2_(v2),
02757       v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
02758       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
02759       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
02760       v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
02761       v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
02762       v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
02763       v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46),
02764       v47_(v47) {}
02765 
02766   template <typename T>
02767   operator ParamGenerator<T>() const {
02768     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
02769         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
02770         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
02771         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
02772         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
02773         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
02774         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
02775         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
02776         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
02777         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
02778         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
02779         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
02780         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
02781         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
02782         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
02783         static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_)};
02784     return ValuesIn(array);
02785   }
02786 
02787  private:
02788   // No implementation - assignment is unsupported.
02789   void operator=(const ValueArray47& other);
02790 
02791   const T1 v1_;
02792   const T2 v2_;
02793   const T3 v3_;
02794   const T4 v4_;
02795   const T5 v5_;
02796   const T6 v6_;
02797   const T7 v7_;
02798   const T8 v8_;
02799   const T9 v9_;
02800   const T10 v10_;
02801   const T11 v11_;
02802   const T12 v12_;
02803   const T13 v13_;
02804   const T14 v14_;
02805   const T15 v15_;
02806   const T16 v16_;
02807   const T17 v17_;
02808   const T18 v18_;
02809   const T19 v19_;
02810   const T20 v20_;
02811   const T21 v21_;
02812   const T22 v22_;
02813   const T23 v23_;
02814   const T24 v24_;
02815   const T25 v25_;
02816   const T26 v26_;
02817   const T27 v27_;
02818   const T28 v28_;
02819   const T29 v29_;
02820   const T30 v30_;
02821   const T31 v31_;
02822   const T32 v32_;
02823   const T33 v33_;
02824   const T34 v34_;
02825   const T35 v35_;
02826   const T36 v36_;
02827   const T37 v37_;
02828   const T38 v38_;
02829   const T39 v39_;
02830   const T40 v40_;
02831   const T41 v41_;
02832   const T42 v42_;
02833   const T43 v43_;
02834   const T44 v44_;
02835   const T45 v45_;
02836   const T46 v46_;
02837   const T47 v47_;
02838 };
02839 
02840 template <typename T1, typename T2, typename T3, typename T4, typename T5,
02841     typename T6, typename T7, typename T8, typename T9, typename T10,
02842     typename T11, typename T12, typename T13, typename T14, typename T15,
02843     typename T16, typename T17, typename T18, typename T19, typename T20,
02844     typename T21, typename T22, typename T23, typename T24, typename T25,
02845     typename T26, typename T27, typename T28, typename T29, typename T30,
02846     typename T31, typename T32, typename T33, typename T34, typename T35,
02847     typename T36, typename T37, typename T38, typename T39, typename T40,
02848     typename T41, typename T42, typename T43, typename T44, typename T45,
02849     typename T46, typename T47, typename T48>
02850 class ValueArray48 {
02851  public:
02852   ValueArray48(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
02853       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
02854       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
02855       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
02856       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
02857       T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48) : v1_(v1),
02858       v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
02859       v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
02860       v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
02861       v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
02862       v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
02863       v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
02864       v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45),
02865       v46_(v46), v47_(v47), v48_(v48) {}
02866 
02867   template <typename T>
02868   operator ParamGenerator<T>() const {
02869     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
02870         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
02871         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
02872         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
02873         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
02874         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
02875         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
02876         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
02877         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
02878         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
02879         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
02880         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
02881         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
02882         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
02883         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
02884         static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
02885         static_cast<T>(v48_)};
02886     return ValuesIn(array);
02887   }
02888 
02889  private:
02890   // No implementation - assignment is unsupported.
02891   void operator=(const ValueArray48& other);
02892 
02893   const T1 v1_;
02894   const T2 v2_;
02895   const T3 v3_;
02896   const T4 v4_;
02897   const T5 v5_;
02898   const T6 v6_;
02899   const T7 v7_;
02900   const T8 v8_;
02901   const T9 v9_;
02902   const T10 v10_;
02903   const T11 v11_;
02904   const T12 v12_;
02905   const T13 v13_;
02906   const T14 v14_;
02907   const T15 v15_;
02908   const T16 v16_;
02909   const T17 v17_;
02910   const T18 v18_;
02911   const T19 v19_;
02912   const T20 v20_;
02913   const T21 v21_;
02914   const T22 v22_;
02915   const T23 v23_;
02916   const T24 v24_;
02917   const T25 v25_;
02918   const T26 v26_;
02919   const T27 v27_;
02920   const T28 v28_;
02921   const T29 v29_;
02922   const T30 v30_;
02923   const T31 v31_;
02924   const T32 v32_;
02925   const T33 v33_;
02926   const T34 v34_;
02927   const T35 v35_;
02928   const T36 v36_;
02929   const T37 v37_;
02930   const T38 v38_;
02931   const T39 v39_;
02932   const T40 v40_;
02933   const T41 v41_;
02934   const T42 v42_;
02935   const T43 v43_;
02936   const T44 v44_;
02937   const T45 v45_;
02938   const T46 v46_;
02939   const T47 v47_;
02940   const T48 v48_;
02941 };
02942 
02943 template <typename T1, typename T2, typename T3, typename T4, typename T5,
02944     typename T6, typename T7, typename T8, typename T9, typename T10,
02945     typename T11, typename T12, typename T13, typename T14, typename T15,
02946     typename T16, typename T17, typename T18, typename T19, typename T20,
02947     typename T21, typename T22, typename T23, typename T24, typename T25,
02948     typename T26, typename T27, typename T28, typename T29, typename T30,
02949     typename T31, typename T32, typename T33, typename T34, typename T35,
02950     typename T36, typename T37, typename T38, typename T39, typename T40,
02951     typename T41, typename T42, typename T43, typename T44, typename T45,
02952     typename T46, typename T47, typename T48, typename T49>
02953 class ValueArray49 {
02954  public:
02955   ValueArray49(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
02956       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
02957       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
02958       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
02959       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
02960       T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48,
02961       T49 v49) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
02962       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
02963       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
02964       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
02965       v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
02966       v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
02967       v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
02968       v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49) {}
02969 
02970   template <typename T>
02971   operator ParamGenerator<T>() const {
02972     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
02973         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
02974         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
02975         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
02976         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
02977         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
02978         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
02979         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
02980         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
02981         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
02982         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
02983         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
02984         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
02985         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
02986         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
02987         static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
02988         static_cast<T>(v48_), static_cast<T>(v49_)};
02989     return ValuesIn(array);
02990   }
02991 
02992  private:
02993   // No implementation - assignment is unsupported.
02994   void operator=(const ValueArray49& other);
02995 
02996   const T1 v1_;
02997   const T2 v2_;
02998   const T3 v3_;
02999   const T4 v4_;
03000   const T5 v5_;
03001   const T6 v6_;
03002   const T7 v7_;
03003   const T8 v8_;
03004   const T9 v9_;
03005   const T10 v10_;
03006   const T11 v11_;
03007   const T12 v12_;
03008   const T13 v13_;
03009   const T14 v14_;
03010   const T15 v15_;
03011   const T16 v16_;
03012   const T17 v17_;
03013   const T18 v18_;
03014   const T19 v19_;
03015   const T20 v20_;
03016   const T21 v21_;
03017   const T22 v22_;
03018   const T23 v23_;
03019   const T24 v24_;
03020   const T25 v25_;
03021   const T26 v26_;
03022   const T27 v27_;
03023   const T28 v28_;
03024   const T29 v29_;
03025   const T30 v30_;
03026   const T31 v31_;
03027   const T32 v32_;
03028   const T33 v33_;
03029   const T34 v34_;
03030   const T35 v35_;
03031   const T36 v36_;
03032   const T37 v37_;
03033   const T38 v38_;
03034   const T39 v39_;
03035   const T40 v40_;
03036   const T41 v41_;
03037   const T42 v42_;
03038   const T43 v43_;
03039   const T44 v44_;
03040   const T45 v45_;
03041   const T46 v46_;
03042   const T47 v47_;
03043   const T48 v48_;
03044   const T49 v49_;
03045 };
03046 
03047 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03048     typename T6, typename T7, typename T8, typename T9, typename T10,
03049     typename T11, typename T12, typename T13, typename T14, typename T15,
03050     typename T16, typename T17, typename T18, typename T19, typename T20,
03051     typename T21, typename T22, typename T23, typename T24, typename T25,
03052     typename T26, typename T27, typename T28, typename T29, typename T30,
03053     typename T31, typename T32, typename T33, typename T34, typename T35,
03054     typename T36, typename T37, typename T38, typename T39, typename T40,
03055     typename T41, typename T42, typename T43, typename T44, typename T45,
03056     typename T46, typename T47, typename T48, typename T49, typename T50>
03057 class ValueArray50 {
03058  public:
03059   ValueArray50(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
03060       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
03061       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
03062       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
03063       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
03064       T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, T49 v49,
03065       T50 v50) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
03066       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
03067       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
03068       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
03069       v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
03070       v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
03071       v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
03072       v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49), v50_(v50) {}
03073 
03074   template <typename T>
03075   operator ParamGenerator<T>() const {
03076     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
03077         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
03078         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
03079         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
03080         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
03081         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
03082         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
03083         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
03084         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
03085         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
03086         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
03087         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
03088         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
03089         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
03090         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
03091         static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
03092         static_cast<T>(v48_), static_cast<T>(v49_), static_cast<T>(v50_)};
03093     return ValuesIn(array);
03094   }
03095 
03096  private:
03097   // No implementation - assignment is unsupported.
03098   void operator=(const ValueArray50& other);
03099 
03100   const T1 v1_;
03101   const T2 v2_;
03102   const T3 v3_;
03103   const T4 v4_;
03104   const T5 v5_;
03105   const T6 v6_;
03106   const T7 v7_;
03107   const T8 v8_;
03108   const T9 v9_;
03109   const T10 v10_;
03110   const T11 v11_;
03111   const T12 v12_;
03112   const T13 v13_;
03113   const T14 v14_;
03114   const T15 v15_;
03115   const T16 v16_;
03116   const T17 v17_;
03117   const T18 v18_;
03118   const T19 v19_;
03119   const T20 v20_;
03120   const T21 v21_;
03121   const T22 v22_;
03122   const T23 v23_;
03123   const T24 v24_;
03124   const T25 v25_;
03125   const T26 v26_;
03126   const T27 v27_;
03127   const T28 v28_;
03128   const T29 v29_;
03129   const T30 v30_;
03130   const T31 v31_;
03131   const T32 v32_;
03132   const T33 v33_;
03133   const T34 v34_;
03134   const T35 v35_;
03135   const T36 v36_;
03136   const T37 v37_;
03137   const T38 v38_;
03138   const T39 v39_;
03139   const T40 v40_;
03140   const T41 v41_;
03141   const T42 v42_;
03142   const T43 v43_;
03143   const T44 v44_;
03144   const T45 v45_;
03145   const T46 v46_;
03146   const T47 v47_;
03147   const T48 v48_;
03148   const T49 v49_;
03149   const T50 v50_;
03150 };
03151 
03152 # if GTEST_HAS_COMBINE
03153 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
03154 //
03155 // Generates values from the Cartesian product of values produced
03156 // by the argument generators.
03157 //
03158 template <typename T1, typename T2>
03159 class CartesianProductGenerator2
03160     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2> > {
03161  public:
03162   typedef ::std::tr1::tuple<T1, T2> ParamType;
03163 
03164   CartesianProductGenerator2(const ParamGenerator<T1>& g1,
03165       const ParamGenerator<T2>& g2)
03166       : g1_(g1), g2_(g2) {}
03167   virtual ~CartesianProductGenerator2() {}
03168 
03169   virtual ParamIteratorInterface<ParamType>* Begin() const {
03170     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin());
03171   }
03172   virtual ParamIteratorInterface<ParamType>* End() const {
03173     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end());
03174   }
03175 
03176  private:
03177   class Iterator : public ParamIteratorInterface<ParamType> {
03178    public:
03179     Iterator(const ParamGeneratorInterface<ParamType>* base,
03180       const ParamGenerator<T1>& g1,
03181       const typename ParamGenerator<T1>::iterator& current1,
03182       const ParamGenerator<T2>& g2,
03183       const typename ParamGenerator<T2>::iterator& current2)
03184         : base_(base),
03185           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
03186           begin2_(g2.begin()), end2_(g2.end()), current2_(current2)    {
03187       ComputeCurrentValue();
03188     }
03189     virtual ~Iterator() {}
03190 
03191     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
03192       return base_;
03193     }
03194     // Advance should not be called on beyond-of-range iterators
03195     // so no component iterators must be beyond end of range, either.
03196     virtual void Advance() {
03197       assert(!AtEnd());
03198       ++current2_;
03199       if (current2_ == end2_) {
03200         current2_ = begin2_;
03201         ++current1_;
03202       }
03203       ComputeCurrentValue();
03204     }
03205     virtual ParamIteratorInterface<ParamType>* Clone() const {
03206       return new Iterator(*this);
03207     }
03208     virtual const ParamType* Current() const { return &current_value_; }
03209     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
03210       // Having the same base generator guarantees that the other
03211       // iterator is of the same type and we can downcast.
03212       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
03213           << "The program attempted to compare iterators "
03214           << "from different generators." << std::endl;
03215       const Iterator* typed_other =
03216           CheckedDowncastToActualType<const Iterator>(&other);
03217       // We must report iterators equal if they both point beyond their
03218       // respective ranges. That can happen in a variety of fashions,
03219       // so we have to consult AtEnd().
03220       return (AtEnd() && typed_other->AtEnd()) ||
03221          (
03222           current1_ == typed_other->current1_ &&
03223           current2_ == typed_other->current2_);
03224     }
03225 
03226    private:
03227     Iterator(const Iterator& other)
03228         : base_(other.base_),
03229         begin1_(other.begin1_),
03230         end1_(other.end1_),
03231         current1_(other.current1_),
03232         begin2_(other.begin2_),
03233         end2_(other.end2_),
03234         current2_(other.current2_) {
03235       ComputeCurrentValue();
03236     }
03237 
03238     void ComputeCurrentValue() {
03239       if (!AtEnd())
03240         current_value_ = ParamType(*current1_, *current2_);
03241     }
03242     bool AtEnd() const {
03243       // We must report iterator past the end of the range when either of the
03244       // component iterators has reached the end of its range.
03245       return
03246           current1_ == end1_ ||
03247           current2_ == end2_;
03248     }
03249 
03250     // No implementation - assignment is unsupported.
03251     void operator=(const Iterator& other);
03252 
03253     const ParamGeneratorInterface<ParamType>* const base_;
03254     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
03255     // current[i]_ is the actual traversing iterator.
03256     const typename ParamGenerator<T1>::iterator begin1_;
03257     const typename ParamGenerator<T1>::iterator end1_;
03258     typename ParamGenerator<T1>::iterator current1_;
03259     const typename ParamGenerator<T2>::iterator begin2_;
03260     const typename ParamGenerator<T2>::iterator end2_;
03261     typename ParamGenerator<T2>::iterator current2_;
03262     ParamType current_value_;
03263   };  // class CartesianProductGenerator2::Iterator
03264 
03265   // No implementation - assignment is unsupported.
03266   void operator=(const CartesianProductGenerator2& other);
03267 
03268   const ParamGenerator<T1> g1_;
03269   const ParamGenerator<T2> g2_;
03270 };  // class CartesianProductGenerator2
03271 
03272 
03273 template <typename T1, typename T2, typename T3>
03274 class CartesianProductGenerator3
03275     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3> > {
03276  public:
03277   typedef ::std::tr1::tuple<T1, T2, T3> ParamType;
03278 
03279   CartesianProductGenerator3(const ParamGenerator<T1>& g1,
03280       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3)
03281       : g1_(g1), g2_(g2), g3_(g3) {}
03282   virtual ~CartesianProductGenerator3() {}
03283 
03284   virtual ParamIteratorInterface<ParamType>* Begin() const {
03285     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
03286         g3_.begin());
03287   }
03288   virtual ParamIteratorInterface<ParamType>* End() const {
03289     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end());
03290   }
03291 
03292  private:
03293   class Iterator : public ParamIteratorInterface<ParamType> {
03294    public:
03295     Iterator(const ParamGeneratorInterface<ParamType>* base,
03296       const ParamGenerator<T1>& g1,
03297       const typename ParamGenerator<T1>::iterator& current1,
03298       const ParamGenerator<T2>& g2,
03299       const typename ParamGenerator<T2>::iterator& current2,
03300       const ParamGenerator<T3>& g3,
03301       const typename ParamGenerator<T3>::iterator& current3)
03302         : base_(base),
03303           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
03304           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
03305           begin3_(g3.begin()), end3_(g3.end()), current3_(current3)    {
03306       ComputeCurrentValue();
03307     }
03308     virtual ~Iterator() {}
03309 
03310     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
03311       return base_;
03312     }
03313     // Advance should not be called on beyond-of-range iterators
03314     // so no component iterators must be beyond end of range, either.
03315     virtual void Advance() {
03316       assert(!AtEnd());
03317       ++current3_;
03318       if (current3_ == end3_) {
03319         current3_ = begin3_;
03320         ++current2_;
03321       }
03322       if (current2_ == end2_) {
03323         current2_ = begin2_;
03324         ++current1_;
03325       }
03326       ComputeCurrentValue();
03327     }
03328     virtual ParamIteratorInterface<ParamType>* Clone() const {
03329       return new Iterator(*this);
03330     }
03331     virtual const ParamType* Current() const { return &current_value_; }
03332     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
03333       // Having the same base generator guarantees that the other
03334       // iterator is of the same type and we can downcast.
03335       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
03336           << "The program attempted to compare iterators "
03337           << "from different generators." << std::endl;
03338       const Iterator* typed_other =
03339           CheckedDowncastToActualType<const Iterator>(&other);
03340       // We must report iterators equal if they both point beyond their
03341       // respective ranges. That can happen in a variety of fashions,
03342       // so we have to consult AtEnd().
03343       return (AtEnd() && typed_other->AtEnd()) ||
03344          (
03345           current1_ == typed_other->current1_ &&
03346           current2_ == typed_other->current2_ &&
03347           current3_ == typed_other->current3_);
03348     }
03349 
03350    private:
03351     Iterator(const Iterator& other)
03352         : base_(other.base_),
03353         begin1_(other.begin1_),
03354         end1_(other.end1_),
03355         current1_(other.current1_),
03356         begin2_(other.begin2_),
03357         end2_(other.end2_),
03358         current2_(other.current2_),
03359         begin3_(other.begin3_),
03360         end3_(other.end3_),
03361         current3_(other.current3_) {
03362       ComputeCurrentValue();
03363     }
03364 
03365     void ComputeCurrentValue() {
03366       if (!AtEnd())
03367         current_value_ = ParamType(*current1_, *current2_, *current3_);
03368     }
03369     bool AtEnd() const {
03370       // We must report iterator past the end of the range when either of the
03371       // component iterators has reached the end of its range.
03372       return
03373           current1_ == end1_ ||
03374           current2_ == end2_ ||
03375           current3_ == end3_;
03376     }
03377 
03378     // No implementation - assignment is unsupported.
03379     void operator=(const Iterator& other);
03380 
03381     const ParamGeneratorInterface<ParamType>* const base_;
03382     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
03383     // current[i]_ is the actual traversing iterator.
03384     const typename ParamGenerator<T1>::iterator begin1_;
03385     const typename ParamGenerator<T1>::iterator end1_;
03386     typename ParamGenerator<T1>::iterator current1_;
03387     const typename ParamGenerator<T2>::iterator begin2_;
03388     const typename ParamGenerator<T2>::iterator end2_;
03389     typename ParamGenerator<T2>::iterator current2_;
03390     const typename ParamGenerator<T3>::iterator begin3_;
03391     const typename ParamGenerator<T3>::iterator end3_;
03392     typename ParamGenerator<T3>::iterator current3_;
03393     ParamType current_value_;
03394   };  // class CartesianProductGenerator3::Iterator
03395 
03396   // No implementation - assignment is unsupported.
03397   void operator=(const CartesianProductGenerator3& other);
03398 
03399   const ParamGenerator<T1> g1_;
03400   const ParamGenerator<T2> g2_;
03401   const ParamGenerator<T3> g3_;
03402 };  // class CartesianProductGenerator3
03403 
03404 
03405 template <typename T1, typename T2, typename T3, typename T4>
03406 class CartesianProductGenerator4
03407     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4> > {
03408  public:
03409   typedef ::std::tr1::tuple<T1, T2, T3, T4> ParamType;
03410 
03411   CartesianProductGenerator4(const ParamGenerator<T1>& g1,
03412       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
03413       const ParamGenerator<T4>& g4)
03414       : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
03415   virtual ~CartesianProductGenerator4() {}
03416 
03417   virtual ParamIteratorInterface<ParamType>* Begin() const {
03418     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
03419         g3_.begin(), g4_, g4_.begin());
03420   }
03421   virtual ParamIteratorInterface<ParamType>* End() const {
03422     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
03423         g4_, g4_.end());
03424   }
03425 
03426  private:
03427   class Iterator : public ParamIteratorInterface<ParamType> {
03428    public:
03429     Iterator(const ParamGeneratorInterface<ParamType>* base,
03430       const ParamGenerator<T1>& g1,
03431       const typename ParamGenerator<T1>::iterator& current1,
03432       const ParamGenerator<T2>& g2,
03433       const typename ParamGenerator<T2>::iterator& current2,
03434       const ParamGenerator<T3>& g3,
03435       const typename ParamGenerator<T3>::iterator& current3,
03436       const ParamGenerator<T4>& g4,
03437       const typename ParamGenerator<T4>::iterator& current4)
03438         : base_(base),
03439           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
03440           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
03441           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
03442           begin4_(g4.begin()), end4_(g4.end()), current4_(current4)    {
03443       ComputeCurrentValue();
03444     }
03445     virtual ~Iterator() {}
03446 
03447     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
03448       return base_;
03449     }
03450     // Advance should not be called on beyond-of-range iterators
03451     // so no component iterators must be beyond end of range, either.
03452     virtual void Advance() {
03453       assert(!AtEnd());
03454       ++current4_;
03455       if (current4_ == end4_) {
03456         current4_ = begin4_;
03457         ++current3_;
03458       }
03459       if (current3_ == end3_) {
03460         current3_ = begin3_;
03461         ++current2_;
03462       }
03463       if (current2_ == end2_) {
03464         current2_ = begin2_;
03465         ++current1_;
03466       }
03467       ComputeCurrentValue();
03468     }
03469     virtual ParamIteratorInterface<ParamType>* Clone() const {
03470       return new Iterator(*this);
03471     }
03472     virtual const ParamType* Current() const { return &current_value_; }
03473     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
03474       // Having the same base generator guarantees that the other
03475       // iterator is of the same type and we can downcast.
03476       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
03477           << "The program attempted to compare iterators "
03478           << "from different generators." << std::endl;
03479       const Iterator* typed_other =
03480           CheckedDowncastToActualType<const Iterator>(&other);
03481       // We must report iterators equal if they both point beyond their
03482       // respective ranges. That can happen in a variety of fashions,
03483       // so we have to consult AtEnd().
03484       return (AtEnd() && typed_other->AtEnd()) ||
03485          (
03486           current1_ == typed_other->current1_ &&
03487           current2_ == typed_other->current2_ &&
03488           current3_ == typed_other->current3_ &&
03489           current4_ == typed_other->current4_);
03490     }
03491 
03492    private:
03493     Iterator(const Iterator& other)
03494         : base_(other.base_),
03495         begin1_(other.begin1_),
03496         end1_(other.end1_),
03497         current1_(other.current1_),
03498         begin2_(other.begin2_),
03499         end2_(other.end2_),
03500         current2_(other.current2_),
03501         begin3_(other.begin3_),
03502         end3_(other.end3_),
03503         current3_(other.current3_),
03504         begin4_(other.begin4_),
03505         end4_(other.end4_),
03506         current4_(other.current4_) {
03507       ComputeCurrentValue();
03508     }
03509 
03510     void ComputeCurrentValue() {
03511       if (!AtEnd())
03512         current_value_ = ParamType(*current1_, *current2_, *current3_,
03513             *current4_);
03514     }
03515     bool AtEnd() const {
03516       // We must report iterator past the end of the range when either of the
03517       // component iterators has reached the end of its range.
03518       return
03519           current1_ == end1_ ||
03520           current2_ == end2_ ||
03521           current3_ == end3_ ||
03522           current4_ == end4_;
03523     }
03524 
03525     // No implementation - assignment is unsupported.
03526     void operator=(const Iterator& other);
03527 
03528     const ParamGeneratorInterface<ParamType>* const base_;
03529     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
03530     // current[i]_ is the actual traversing iterator.
03531     const typename ParamGenerator<T1>::iterator begin1_;
03532     const typename ParamGenerator<T1>::iterator end1_;
03533     typename ParamGenerator<T1>::iterator current1_;
03534     const typename ParamGenerator<T2>::iterator begin2_;
03535     const typename ParamGenerator<T2>::iterator end2_;
03536     typename ParamGenerator<T2>::iterator current2_;
03537     const typename ParamGenerator<T3>::iterator begin3_;
03538     const typename ParamGenerator<T3>::iterator end3_;
03539     typename ParamGenerator<T3>::iterator current3_;
03540     const typename ParamGenerator<T4>::iterator begin4_;
03541     const typename ParamGenerator<T4>::iterator end4_;
03542     typename ParamGenerator<T4>::iterator current4_;
03543     ParamType current_value_;
03544   };  // class CartesianProductGenerator4::Iterator
03545 
03546   // No implementation - assignment is unsupported.
03547   void operator=(const CartesianProductGenerator4& other);
03548 
03549   const ParamGenerator<T1> g1_;
03550   const ParamGenerator<T2> g2_;
03551   const ParamGenerator<T3> g3_;
03552   const ParamGenerator<T4> g4_;
03553 };  // class CartesianProductGenerator4
03554 
03555 
03556 template <typename T1, typename T2, typename T3, typename T4, typename T5>
03557 class CartesianProductGenerator5
03558     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5> > {
03559  public:
03560   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5> ParamType;
03561 
03562   CartesianProductGenerator5(const ParamGenerator<T1>& g1,
03563       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
03564       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5)
03565       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
03566   virtual ~CartesianProductGenerator5() {}
03567 
03568   virtual ParamIteratorInterface<ParamType>* Begin() const {
03569     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
03570         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin());
03571   }
03572   virtual ParamIteratorInterface<ParamType>* End() const {
03573     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
03574         g4_, g4_.end(), g5_, g5_.end());
03575   }
03576 
03577  private:
03578   class Iterator : public ParamIteratorInterface<ParamType> {
03579    public:
03580     Iterator(const ParamGeneratorInterface<ParamType>* base,
03581       const ParamGenerator<T1>& g1,
03582       const typename ParamGenerator<T1>::iterator& current1,
03583       const ParamGenerator<T2>& g2,
03584       const typename ParamGenerator<T2>::iterator& current2,
03585       const ParamGenerator<T3>& g3,
03586       const typename ParamGenerator<T3>::iterator& current3,
03587       const ParamGenerator<T4>& g4,
03588       const typename ParamGenerator<T4>::iterator& current4,
03589       const ParamGenerator<T5>& g5,
03590       const typename ParamGenerator<T5>::iterator& current5)
03591         : base_(base),
03592           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
03593           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
03594           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
03595           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
03596           begin5_(g5.begin()), end5_(g5.end()), current5_(current5)    {
03597       ComputeCurrentValue();
03598     }
03599     virtual ~Iterator() {}
03600 
03601     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
03602       return base_;
03603     }
03604     // Advance should not be called on beyond-of-range iterators
03605     // so no component iterators must be beyond end of range, either.
03606     virtual void Advance() {
03607       assert(!AtEnd());
03608       ++current5_;
03609       if (current5_ == end5_) {
03610         current5_ = begin5_;
03611         ++current4_;
03612       }
03613       if (current4_ == end4_) {
03614         current4_ = begin4_;
03615         ++current3_;
03616       }
03617       if (current3_ == end3_) {
03618         current3_ = begin3_;
03619         ++current2_;
03620       }
03621       if (current2_ == end2_) {
03622         current2_ = begin2_;
03623         ++current1_;
03624       }
03625       ComputeCurrentValue();
03626     }
03627     virtual ParamIteratorInterface<ParamType>* Clone() const {
03628       return new Iterator(*this);
03629     }
03630     virtual const ParamType* Current() const { return &current_value_; }
03631     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
03632       // Having the same base generator guarantees that the other
03633       // iterator is of the same type and we can downcast.
03634       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
03635           << "The program attempted to compare iterators "
03636           << "from different generators." << std::endl;
03637       const Iterator* typed_other =
03638           CheckedDowncastToActualType<const Iterator>(&other);
03639       // We must report iterators equal if they both point beyond their
03640       // respective ranges. That can happen in a variety of fashions,
03641       // so we have to consult AtEnd().
03642       return (AtEnd() && typed_other->AtEnd()) ||
03643          (
03644           current1_ == typed_other->current1_ &&
03645           current2_ == typed_other->current2_ &&
03646           current3_ == typed_other->current3_ &&
03647           current4_ == typed_other->current4_ &&
03648           current5_ == typed_other->current5_);
03649     }
03650 
03651    private:
03652     Iterator(const Iterator& other)
03653         : base_(other.base_),
03654         begin1_(other.begin1_),
03655         end1_(other.end1_),
03656         current1_(other.current1_),
03657         begin2_(other.begin2_),
03658         end2_(other.end2_),
03659         current2_(other.current2_),
03660         begin3_(other.begin3_),
03661         end3_(other.end3_),
03662         current3_(other.current3_),
03663         begin4_(other.begin4_),
03664         end4_(other.end4_),
03665         current4_(other.current4_),
03666         begin5_(other.begin5_),
03667         end5_(other.end5_),
03668         current5_(other.current5_) {
03669       ComputeCurrentValue();
03670     }
03671 
03672     void ComputeCurrentValue() {
03673       if (!AtEnd())
03674         current_value_ = ParamType(*current1_, *current2_, *current3_,
03675             *current4_, *current5_);
03676     }
03677     bool AtEnd() const {
03678       // We must report iterator past the end of the range when either of the
03679       // component iterators has reached the end of its range.
03680       return
03681           current1_ == end1_ ||
03682           current2_ == end2_ ||
03683           current3_ == end3_ ||
03684           current4_ == end4_ ||
03685           current5_ == end5_;
03686     }
03687 
03688     // No implementation - assignment is unsupported.
03689     void operator=(const Iterator& other);
03690 
03691     const ParamGeneratorInterface<ParamType>* const base_;
03692     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
03693     // current[i]_ is the actual traversing iterator.
03694     const typename ParamGenerator<T1>::iterator begin1_;
03695     const typename ParamGenerator<T1>::iterator end1_;
03696     typename ParamGenerator<T1>::iterator current1_;
03697     const typename ParamGenerator<T2>::iterator begin2_;
03698     const typename ParamGenerator<T2>::iterator end2_;
03699     typename ParamGenerator<T2>::iterator current2_;
03700     const typename ParamGenerator<T3>::iterator begin3_;
03701     const typename ParamGenerator<T3>::iterator end3_;
03702     typename ParamGenerator<T3>::iterator current3_;
03703     const typename ParamGenerator<T4>::iterator begin4_;
03704     const typename ParamGenerator<T4>::iterator end4_;
03705     typename ParamGenerator<T4>::iterator current4_;
03706     const typename ParamGenerator<T5>::iterator begin5_;
03707     const typename ParamGenerator<T5>::iterator end5_;
03708     typename ParamGenerator<T5>::iterator current5_;
03709     ParamType current_value_;
03710   };  // class CartesianProductGenerator5::Iterator
03711 
03712   // No implementation - assignment is unsupported.
03713   void operator=(const CartesianProductGenerator5& other);
03714 
03715   const ParamGenerator<T1> g1_;
03716   const ParamGenerator<T2> g2_;
03717   const ParamGenerator<T3> g3_;
03718   const ParamGenerator<T4> g4_;
03719   const ParamGenerator<T5> g5_;
03720 };  // class CartesianProductGenerator5
03721 
03722 
03723 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03724     typename T6>
03725 class CartesianProductGenerator6
03726     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5,
03727         T6> > {
03728  public:
03729   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> ParamType;
03730 
03731   CartesianProductGenerator6(const ParamGenerator<T1>& g1,
03732       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
03733       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
03734       const ParamGenerator<T6>& g6)
03735       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
03736   virtual ~CartesianProductGenerator6() {}
03737 
03738   virtual ParamIteratorInterface<ParamType>* Begin() const {
03739     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
03740         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin());
03741   }
03742   virtual ParamIteratorInterface<ParamType>* End() const {
03743     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
03744         g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end());
03745   }
03746 
03747  private:
03748   class Iterator : public ParamIteratorInterface<ParamType> {
03749    public:
03750     Iterator(const ParamGeneratorInterface<ParamType>* base,
03751       const ParamGenerator<T1>& g1,
03752       const typename ParamGenerator<T1>::iterator& current1,
03753       const ParamGenerator<T2>& g2,
03754       const typename ParamGenerator<T2>::iterator& current2,
03755       const ParamGenerator<T3>& g3,
03756       const typename ParamGenerator<T3>::iterator& current3,
03757       const ParamGenerator<T4>& g4,
03758       const typename ParamGenerator<T4>::iterator& current4,
03759       const ParamGenerator<T5>& g5,
03760       const typename ParamGenerator<T5>::iterator& current5,
03761       const ParamGenerator<T6>& g6,
03762       const typename ParamGenerator<T6>::iterator& current6)
03763         : base_(base),
03764           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
03765           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
03766           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
03767           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
03768           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
03769           begin6_(g6.begin()), end6_(g6.end()), current6_(current6)    {
03770       ComputeCurrentValue();
03771     }
03772     virtual ~Iterator() {}
03773 
03774     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
03775       return base_;
03776     }
03777     // Advance should not be called on beyond-of-range iterators
03778     // so no component iterators must be beyond end of range, either.
03779     virtual void Advance() {
03780       assert(!AtEnd());
03781       ++current6_;
03782       if (current6_ == end6_) {
03783         current6_ = begin6_;
03784         ++current5_;
03785       }
03786       if (current5_ == end5_) {
03787         current5_ = begin5_;
03788         ++current4_;
03789       }
03790       if (current4_ == end4_) {
03791         current4_ = begin4_;
03792         ++current3_;
03793       }
03794       if (current3_ == end3_) {
03795         current3_ = begin3_;
03796         ++current2_;
03797       }
03798       if (current2_ == end2_) {
03799         current2_ = begin2_;
03800         ++current1_;
03801       }
03802       ComputeCurrentValue();
03803     }
03804     virtual ParamIteratorInterface<ParamType>* Clone() const {
03805       return new Iterator(*this);
03806     }
03807     virtual const ParamType* Current() const { return &current_value_; }
03808     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
03809       // Having the same base generator guarantees that the other
03810       // iterator is of the same type and we can downcast.
03811       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
03812           << "The program attempted to compare iterators "
03813           << "from different generators." << std::endl;
03814       const Iterator* typed_other =
03815           CheckedDowncastToActualType<const Iterator>(&other);
03816       // We must report iterators equal if they both point beyond their
03817       // respective ranges. That can happen in a variety of fashions,
03818       // so we have to consult AtEnd().
03819       return (AtEnd() && typed_other->AtEnd()) ||
03820          (
03821           current1_ == typed_other->current1_ &&
03822           current2_ == typed_other->current2_ &&
03823           current3_ == typed_other->current3_ &&
03824           current4_ == typed_other->current4_ &&
03825           current5_ == typed_other->current5_ &&
03826           current6_ == typed_other->current6_);
03827     }
03828 
03829    private:
03830     Iterator(const Iterator& other)
03831         : base_(other.base_),
03832         begin1_(other.begin1_),
03833         end1_(other.end1_),
03834         current1_(other.current1_),
03835         begin2_(other.begin2_),
03836         end2_(other.end2_),
03837         current2_(other.current2_),
03838         begin3_(other.begin3_),
03839         end3_(other.end3_),
03840         current3_(other.current3_),
03841         begin4_(other.begin4_),
03842         end4_(other.end4_),
03843         current4_(other.current4_),
03844         begin5_(other.begin5_),
03845         end5_(other.end5_),
03846         current5_(other.current5_),
03847         begin6_(other.begin6_),
03848         end6_(other.end6_),
03849         current6_(other.current6_) {
03850       ComputeCurrentValue();
03851     }
03852 
03853     void ComputeCurrentValue() {
03854       if (!AtEnd())
03855         current_value_ = ParamType(*current1_, *current2_, *current3_,
03856             *current4_, *current5_, *current6_);
03857     }
03858     bool AtEnd() const {
03859       // We must report iterator past the end of the range when either of the
03860       // component iterators has reached the end of its range.
03861       return
03862           current1_ == end1_ ||
03863           current2_ == end2_ ||
03864           current3_ == end3_ ||
03865           current4_ == end4_ ||
03866           current5_ == end5_ ||
03867           current6_ == end6_;
03868     }
03869 
03870     // No implementation - assignment is unsupported.
03871     void operator=(const Iterator& other);
03872 
03873     const ParamGeneratorInterface<ParamType>* const base_;
03874     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
03875     // current[i]_ is the actual traversing iterator.
03876     const typename ParamGenerator<T1>::iterator begin1_;
03877     const typename ParamGenerator<T1>::iterator end1_;
03878     typename ParamGenerator<T1>::iterator current1_;
03879     const typename ParamGenerator<T2>::iterator begin2_;
03880     const typename ParamGenerator<T2>::iterator end2_;
03881     typename ParamGenerator<T2>::iterator current2_;
03882     const typename ParamGenerator<T3>::iterator begin3_;
03883     const typename ParamGenerator<T3>::iterator end3_;
03884     typename ParamGenerator<T3>::iterator current3_;
03885     const typename ParamGenerator<T4>::iterator begin4_;
03886     const typename ParamGenerator<T4>::iterator end4_;
03887     typename ParamGenerator<T4>::iterator current4_;
03888     const typename ParamGenerator<T5>::iterator begin5_;
03889     const typename ParamGenerator<T5>::iterator end5_;
03890     typename ParamGenerator<T5>::iterator current5_;
03891     const typename ParamGenerator<T6>::iterator begin6_;
03892     const typename ParamGenerator<T6>::iterator end6_;
03893     typename ParamGenerator<T6>::iterator current6_;
03894     ParamType current_value_;
03895   };  // class CartesianProductGenerator6::Iterator
03896 
03897   // No implementation - assignment is unsupported.
03898   void operator=(const CartesianProductGenerator6& other);
03899 
03900   const ParamGenerator<T1> g1_;
03901   const ParamGenerator<T2> g2_;
03902   const ParamGenerator<T3> g3_;
03903   const ParamGenerator<T4> g4_;
03904   const ParamGenerator<T5> g5_;
03905   const ParamGenerator<T6> g6_;
03906 };  // class CartesianProductGenerator6
03907 
03908 
03909 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03910     typename T6, typename T7>
03911 class CartesianProductGenerator7
03912     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
03913         T7> > {
03914  public:
03915   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7> ParamType;
03916 
03917   CartesianProductGenerator7(const ParamGenerator<T1>& g1,
03918       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
03919       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
03920       const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7)
03921       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
03922   virtual ~CartesianProductGenerator7() {}
03923 
03924   virtual ParamIteratorInterface<ParamType>* Begin() const {
03925     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
03926         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
03927         g7_.begin());
03928   }
03929   virtual ParamIteratorInterface<ParamType>* End() const {
03930     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
03931         g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end());
03932   }
03933 
03934  private:
03935   class Iterator : public ParamIteratorInterface<ParamType> {
03936    public:
03937     Iterator(const ParamGeneratorInterface<ParamType>* base,
03938       const ParamGenerator<T1>& g1,
03939       const typename ParamGenerator<T1>::iterator& current1,
03940       const ParamGenerator<T2>& g2,
03941       const typename ParamGenerator<T2>::iterator& current2,
03942       const ParamGenerator<T3>& g3,
03943       const typename ParamGenerator<T3>::iterator& current3,
03944       const ParamGenerator<T4>& g4,
03945       const typename ParamGenerator<T4>::iterator& current4,
03946       const ParamGenerator<T5>& g5,
03947       const typename ParamGenerator<T5>::iterator& current5,
03948       const ParamGenerator<T6>& g6,
03949       const typename ParamGenerator<T6>::iterator& current6,
03950       const ParamGenerator<T7>& g7,
03951       const typename ParamGenerator<T7>::iterator& current7)
03952         : base_(base),
03953           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
03954           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
03955           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
03956           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
03957           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
03958           begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
03959           begin7_(g7.begin()), end7_(g7.end()), current7_(current7)    {
03960       ComputeCurrentValue();
03961     }
03962     virtual ~Iterator() {}
03963 
03964     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
03965       return base_;
03966     }
03967     // Advance should not be called on beyond-of-range iterators
03968     // so no component iterators must be beyond end of range, either.
03969     virtual void Advance() {
03970       assert(!AtEnd());
03971       ++current7_;
03972       if (current7_ == end7_) {
03973         current7_ = begin7_;
03974         ++current6_;
03975       }
03976       if (current6_ == end6_) {
03977         current6_ = begin6_;
03978         ++current5_;
03979       }
03980       if (current5_ == end5_) {
03981         current5_ = begin5_;
03982         ++current4_;
03983       }
03984       if (current4_ == end4_) {
03985         current4_ = begin4_;
03986         ++current3_;
03987       }
03988       if (current3_ == end3_) {
03989         current3_ = begin3_;
03990         ++current2_;
03991       }
03992       if (current2_ == end2_) {
03993         current2_ = begin2_;
03994         ++current1_;
03995       }
03996       ComputeCurrentValue();
03997     }
03998     virtual ParamIteratorInterface<ParamType>* Clone() const {
03999       return new Iterator(*this);
04000     }
04001     virtual const ParamType* Current() const { return &current_value_; }
04002     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
04003       // Having the same base generator guarantees that the other
04004       // iterator is of the same type and we can downcast.
04005       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
04006           << "The program attempted to compare iterators "
04007           << "from different generators." << std::endl;
04008       const Iterator* typed_other =
04009           CheckedDowncastToActualType<const Iterator>(&other);
04010       // We must report iterators equal if they both point beyond their
04011       // respective ranges. That can happen in a variety of fashions,
04012       // so we have to consult AtEnd().
04013       return (AtEnd() && typed_other->AtEnd()) ||
04014          (
04015           current1_ == typed_other->current1_ &&
04016           current2_ == typed_other->current2_ &&
04017           current3_ == typed_other->current3_ &&
04018           current4_ == typed_other->current4_ &&
04019           current5_ == typed_other->current5_ &&
04020           current6_ == typed_other->current6_ &&
04021           current7_ == typed_other->current7_);
04022     }
04023 
04024    private:
04025     Iterator(const Iterator& other)
04026         : base_(other.base_),
04027         begin1_(other.begin1_),
04028         end1_(other.end1_),
04029         current1_(other.current1_),
04030         begin2_(other.begin2_),
04031         end2_(other.end2_),
04032         current2_(other.current2_),
04033         begin3_(other.begin3_),
04034         end3_(other.end3_),
04035         current3_(other.current3_),
04036         begin4_(other.begin4_),
04037         end4_(other.end4_),
04038         current4_(other.current4_),
04039         begin5_(other.begin5_),
04040         end5_(other.end5_),
04041         current5_(other.current5_),
04042         begin6_(other.begin6_),
04043         end6_(other.end6_),
04044         current6_(other.current6_),
04045         begin7_(other.begin7_),
04046         end7_(other.end7_),
04047         current7_(other.current7_) {
04048       ComputeCurrentValue();
04049     }
04050 
04051     void ComputeCurrentValue() {
04052       if (!AtEnd())
04053         current_value_ = ParamType(*current1_, *current2_, *current3_,
04054             *current4_, *current5_, *current6_, *current7_);
04055     }
04056     bool AtEnd() const {
04057       // We must report iterator past the end of the range when either of the
04058       // component iterators has reached the end of its range.
04059       return
04060           current1_ == end1_ ||
04061           current2_ == end2_ ||
04062           current3_ == end3_ ||
04063           current4_ == end4_ ||
04064           current5_ == end5_ ||
04065           current6_ == end6_ ||
04066           current7_ == end7_;
04067     }
04068 
04069     // No implementation - assignment is unsupported.
04070     void operator=(const Iterator& other);
04071 
04072     const ParamGeneratorInterface<ParamType>* const base_;
04073     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
04074     // current[i]_ is the actual traversing iterator.
04075     const typename ParamGenerator<T1>::iterator begin1_;
04076     const typename ParamGenerator<T1>::iterator end1_;
04077     typename ParamGenerator<T1>::iterator current1_;
04078     const typename ParamGenerator<T2>::iterator begin2_;
04079     const typename ParamGenerator<T2>::iterator end2_;
04080     typename ParamGenerator<T2>::iterator current2_;
04081     const typename ParamGenerator<T3>::iterator begin3_;
04082     const typename ParamGenerator<T3>::iterator end3_;
04083     typename ParamGenerator<T3>::iterator current3_;
04084     const typename ParamGenerator<T4>::iterator begin4_;
04085     const typename ParamGenerator<T4>::iterator end4_;
04086     typename ParamGenerator<T4>::iterator current4_;
04087     const typename ParamGenerator<T5>::iterator begin5_;
04088     const typename ParamGenerator<T5>::iterator end5_;
04089     typename ParamGenerator<T5>::iterator current5_;
04090     const typename ParamGenerator<T6>::iterator begin6_;
04091     const typename ParamGenerator<T6>::iterator end6_;
04092     typename ParamGenerator<T6>::iterator current6_;
04093     const typename ParamGenerator<T7>::iterator begin7_;
04094     const typename ParamGenerator<T7>::iterator end7_;
04095     typename ParamGenerator<T7>::iterator current7_;
04096     ParamType current_value_;
04097   };  // class CartesianProductGenerator7::Iterator
04098 
04099   // No implementation - assignment is unsupported.
04100   void operator=(const CartesianProductGenerator7& other);
04101 
04102   const ParamGenerator<T1> g1_;
04103   const ParamGenerator<T2> g2_;
04104   const ParamGenerator<T3> g3_;
04105   const ParamGenerator<T4> g4_;
04106   const ParamGenerator<T5> g5_;
04107   const ParamGenerator<T6> g6_;
04108   const ParamGenerator<T7> g7_;
04109 };  // class CartesianProductGenerator7
04110 
04111 
04112 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04113     typename T6, typename T7, typename T8>
04114 class CartesianProductGenerator8
04115     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
04116         T7, T8> > {
04117  public:
04118   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8> ParamType;
04119 
04120   CartesianProductGenerator8(const ParamGenerator<T1>& g1,
04121       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
04122       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
04123       const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
04124       const ParamGenerator<T8>& g8)
04125       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
04126           g8_(g8) {}
04127   virtual ~CartesianProductGenerator8() {}
04128 
04129   virtual ParamIteratorInterface<ParamType>* Begin() const {
04130     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
04131         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
04132         g7_.begin(), g8_, g8_.begin());
04133   }
04134   virtual ParamIteratorInterface<ParamType>* End() const {
04135     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
04136         g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
04137         g8_.end());
04138   }
04139 
04140  private:
04141   class Iterator : public ParamIteratorInterface<ParamType> {
04142    public:
04143     Iterator(const ParamGeneratorInterface<ParamType>* base,
04144       const ParamGenerator<T1>& g1,
04145       const typename ParamGenerator<T1>::iterator& current1,
04146       const ParamGenerator<T2>& g2,
04147       const typename ParamGenerator<T2>::iterator& current2,
04148       const ParamGenerator<T3>& g3,
04149       const typename ParamGenerator<T3>::iterator& current3,
04150       const ParamGenerator<T4>& g4,
04151       const typename ParamGenerator<T4>::iterator& current4,
04152       const ParamGenerator<T5>& g5,
04153       const typename ParamGenerator<T5>::iterator& current5,
04154       const ParamGenerator<T6>& g6,
04155       const typename ParamGenerator<T6>::iterator& current6,
04156       const ParamGenerator<T7>& g7,
04157       const typename ParamGenerator<T7>::iterator& current7,
04158       const ParamGenerator<T8>& g8,
04159       const typename ParamGenerator<T8>::iterator& current8)
04160         : base_(base),
04161           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
04162           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
04163           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
04164           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
04165           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
04166           begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
04167           begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
04168           begin8_(g8.begin()), end8_(g8.end()), current8_(current8)    {
04169       ComputeCurrentValue();
04170     }
04171     virtual ~Iterator() {}
04172 
04173     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
04174       return base_;
04175     }
04176     // Advance should not be called on beyond-of-range iterators
04177     // so no component iterators must be beyond end of range, either.
04178     virtual void Advance() {
04179       assert(!AtEnd());
04180       ++current8_;
04181       if (current8_ == end8_) {
04182         current8_ = begin8_;
04183         ++current7_;
04184       }
04185       if (current7_ == end7_) {
04186         current7_ = begin7_;
04187         ++current6_;
04188       }
04189       if (current6_ == end6_) {
04190         current6_ = begin6_;
04191         ++current5_;
04192       }
04193       if (current5_ == end5_) {
04194         current5_ = begin5_;
04195         ++current4_;
04196       }
04197       if (current4_ == end4_) {
04198         current4_ = begin4_;
04199         ++current3_;
04200       }
04201       if (current3_ == end3_) {
04202         current3_ = begin3_;
04203         ++current2_;
04204       }
04205       if (current2_ == end2_) {
04206         current2_ = begin2_;
04207         ++current1_;
04208       }
04209       ComputeCurrentValue();
04210     }
04211     virtual ParamIteratorInterface<ParamType>* Clone() const {
04212       return new Iterator(*this);
04213     }
04214     virtual const ParamType* Current() const { return &current_value_; }
04215     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
04216       // Having the same base generator guarantees that the other
04217       // iterator is of the same type and we can downcast.
04218       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
04219           << "The program attempted to compare iterators "
04220           << "from different generators." << std::endl;
04221       const Iterator* typed_other =
04222           CheckedDowncastToActualType<const Iterator>(&other);
04223       // We must report iterators equal if they both point beyond their
04224       // respective ranges. That can happen in a variety of fashions,
04225       // so we have to consult AtEnd().
04226       return (AtEnd() && typed_other->AtEnd()) ||
04227          (
04228           current1_ == typed_other->current1_ &&
04229           current2_ == typed_other->current2_ &&
04230           current3_ == typed_other->current3_ &&
04231           current4_ == typed_other->current4_ &&
04232           current5_ == typed_other->current5_ &&
04233           current6_ == typed_other->current6_ &&
04234           current7_ == typed_other->current7_ &&
04235           current8_ == typed_other->current8_);
04236     }
04237 
04238    private:
04239     Iterator(const Iterator& other)
04240         : base_(other.base_),
04241         begin1_(other.begin1_),
04242         end1_(other.end1_),
04243         current1_(other.current1_),
04244         begin2_(other.begin2_),
04245         end2_(other.end2_),
04246         current2_(other.current2_),
04247         begin3_(other.begin3_),
04248         end3_(other.end3_),
04249         current3_(other.current3_),
04250         begin4_(other.begin4_),
04251         end4_(other.end4_),
04252         current4_(other.current4_),
04253         begin5_(other.begin5_),
04254         end5_(other.end5_),
04255         current5_(other.current5_),
04256         begin6_(other.begin6_),
04257         end6_(other.end6_),
04258         current6_(other.current6_),
04259         begin7_(other.begin7_),
04260         end7_(other.end7_),
04261         current7_(other.current7_),
04262         begin8_(other.begin8_),
04263         end8_(other.end8_),
04264         current8_(other.current8_) {
04265       ComputeCurrentValue();
04266     }
04267 
04268     void ComputeCurrentValue() {
04269       if (!AtEnd())
04270         current_value_ = ParamType(*current1_, *current2_, *current3_,
04271             *current4_, *current5_, *current6_, *current7_, *current8_);
04272     }
04273     bool AtEnd() const {
04274       // We must report iterator past the end of the range when either of the
04275       // component iterators has reached the end of its range.
04276       return
04277           current1_ == end1_ ||
04278           current2_ == end2_ ||
04279           current3_ == end3_ ||
04280           current4_ == end4_ ||
04281           current5_ == end5_ ||
04282           current6_ == end6_ ||
04283           current7_ == end7_ ||
04284           current8_ == end8_;
04285     }
04286 
04287     // No implementation - assignment is unsupported.
04288     void operator=(const Iterator& other);
04289 
04290     const ParamGeneratorInterface<ParamType>* const base_;
04291     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
04292     // current[i]_ is the actual traversing iterator.
04293     const typename ParamGenerator<T1>::iterator begin1_;
04294     const typename ParamGenerator<T1>::iterator end1_;
04295     typename ParamGenerator<T1>::iterator current1_;
04296     const typename ParamGenerator<T2>::iterator begin2_;
04297     const typename ParamGenerator<T2>::iterator end2_;
04298     typename ParamGenerator<T2>::iterator current2_;
04299     const typename ParamGenerator<T3>::iterator begin3_;
04300     const typename ParamGenerator<T3>::iterator end3_;
04301     typename ParamGenerator<T3>::iterator current3_;
04302     const typename ParamGenerator<T4>::iterator begin4_;
04303     const typename ParamGenerator<T4>::iterator end4_;
04304     typename ParamGenerator<T4>::iterator current4_;
04305     const typename ParamGenerator<T5>::iterator begin5_;
04306     const typename ParamGenerator<T5>::iterator end5_;
04307     typename ParamGenerator<T5>::iterator current5_;
04308     const typename ParamGenerator<T6>::iterator begin6_;
04309     const typename ParamGenerator<T6>::iterator end6_;
04310     typename ParamGenerator<T6>::iterator current6_;
04311     const typename ParamGenerator<T7>::iterator begin7_;
04312     const typename ParamGenerator<T7>::iterator end7_;
04313     typename ParamGenerator<T7>::iterator current7_;
04314     const typename ParamGenerator<T8>::iterator begin8_;
04315     const typename ParamGenerator<T8>::iterator end8_;
04316     typename ParamGenerator<T8>::iterator current8_;
04317     ParamType current_value_;
04318   };  // class CartesianProductGenerator8::Iterator
04319 
04320   // No implementation - assignment is unsupported.
04321   void operator=(const CartesianProductGenerator8& other);
04322 
04323   const ParamGenerator<T1> g1_;
04324   const ParamGenerator<T2> g2_;
04325   const ParamGenerator<T3> g3_;
04326   const ParamGenerator<T4> g4_;
04327   const ParamGenerator<T5> g5_;
04328   const ParamGenerator<T6> g6_;
04329   const ParamGenerator<T7> g7_;
04330   const ParamGenerator<T8> g8_;
04331 };  // class CartesianProductGenerator8
04332 
04333 
04334 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04335     typename T6, typename T7, typename T8, typename T9>
04336 class CartesianProductGenerator9
04337     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
04338         T7, T8, T9> > {
04339  public:
04340   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> ParamType;
04341 
04342   CartesianProductGenerator9(const ParamGenerator<T1>& g1,
04343       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
04344       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
04345       const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
04346       const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9)
04347       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
04348           g9_(g9) {}
04349   virtual ~CartesianProductGenerator9() {}
04350 
04351   virtual ParamIteratorInterface<ParamType>* Begin() const {
04352     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
04353         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
04354         g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin());
04355   }
04356   virtual ParamIteratorInterface<ParamType>* End() const {
04357     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
04358         g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
04359         g8_.end(), g9_, g9_.end());
04360   }
04361 
04362  private:
04363   class Iterator : public ParamIteratorInterface<ParamType> {
04364    public:
04365     Iterator(const ParamGeneratorInterface<ParamType>* base,
04366       const ParamGenerator<T1>& g1,
04367       const typename ParamGenerator<T1>::iterator& current1,
04368       const ParamGenerator<T2>& g2,
04369       const typename ParamGenerator<T2>::iterator& current2,
04370       const ParamGenerator<T3>& g3,
04371       const typename ParamGenerator<T3>::iterator& current3,
04372       const ParamGenerator<T4>& g4,
04373       const typename ParamGenerator<T4>::iterator& current4,
04374       const ParamGenerator<T5>& g5,
04375       const typename ParamGenerator<T5>::iterator& current5,
04376       const ParamGenerator<T6>& g6,
04377       const typename ParamGenerator<T6>::iterator& current6,
04378       const ParamGenerator<T7>& g7,
04379       const typename ParamGenerator<T7>::iterator& current7,
04380       const ParamGenerator<T8>& g8,
04381       const typename ParamGenerator<T8>::iterator& current8,
04382       const ParamGenerator<T9>& g9,
04383       const typename ParamGenerator<T9>::iterator& current9)
04384         : base_(base),
04385           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
04386           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
04387           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
04388           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
04389           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
04390           begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
04391           begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
04392           begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
04393           begin9_(g9.begin()), end9_(g9.end()), current9_(current9)    {
04394       ComputeCurrentValue();
04395     }
04396     virtual ~Iterator() {}
04397 
04398     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
04399       return base_;
04400     }
04401     // Advance should not be called on beyond-of-range iterators
04402     // so no component iterators must be beyond end of range, either.
04403     virtual void Advance() {
04404       assert(!AtEnd());
04405       ++current9_;
04406       if (current9_ == end9_) {
04407         current9_ = begin9_;
04408         ++current8_;
04409       }
04410       if (current8_ == end8_) {
04411         current8_ = begin8_;
04412         ++current7_;
04413       }
04414       if (current7_ == end7_) {
04415         current7_ = begin7_;
04416         ++current6_;
04417       }
04418       if (current6_ == end6_) {
04419         current6_ = begin6_;
04420         ++current5_;
04421       }
04422       if (current5_ == end5_) {
04423         current5_ = begin5_;
04424         ++current4_;
04425       }
04426       if (current4_ == end4_) {
04427         current4_ = begin4_;
04428         ++current3_;
04429       }
04430       if (current3_ == end3_) {
04431         current3_ = begin3_;
04432         ++current2_;
04433       }
04434       if (current2_ == end2_) {
04435         current2_ = begin2_;
04436         ++current1_;
04437       }
04438       ComputeCurrentValue();
04439     }
04440     virtual ParamIteratorInterface<ParamType>* Clone() const {
04441       return new Iterator(*this);
04442     }
04443     virtual const ParamType* Current() const { return &current_value_; }
04444     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
04445       // Having the same base generator guarantees that the other
04446       // iterator is of the same type and we can downcast.
04447       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
04448           << "The program attempted to compare iterators "
04449           << "from different generators." << std::endl;
04450       const Iterator* typed_other =
04451           CheckedDowncastToActualType<const Iterator>(&other);
04452       // We must report iterators equal if they both point beyond their
04453       // respective ranges. That can happen in a variety of fashions,
04454       // so we have to consult AtEnd().
04455       return (AtEnd() && typed_other->AtEnd()) ||
04456          (
04457           current1_ == typed_other->current1_ &&
04458           current2_ == typed_other->current2_ &&
04459           current3_ == typed_other->current3_ &&
04460           current4_ == typed_other->current4_ &&
04461           current5_ == typed_other->current5_ &&
04462           current6_ == typed_other->current6_ &&
04463           current7_ == typed_other->current7_ &&
04464           current8_ == typed_other->current8_ &&
04465           current9_ == typed_other->current9_);
04466     }
04467 
04468    private:
04469     Iterator(const Iterator& other)
04470         : base_(other.base_),
04471         begin1_(other.begin1_),
04472         end1_(other.end1_),
04473         current1_(other.current1_),
04474         begin2_(other.begin2_),
04475         end2_(other.end2_),
04476         current2_(other.current2_),
04477         begin3_(other.begin3_),
04478         end3_(other.end3_),
04479         current3_(other.current3_),
04480         begin4_(other.begin4_),
04481         end4_(other.end4_),
04482         current4_(other.current4_),
04483         begin5_(other.begin5_),
04484         end5_(other.end5_),
04485         current5_(other.current5_),
04486         begin6_(other.begin6_),
04487         end6_(other.end6_),
04488         current6_(other.current6_),
04489         begin7_(other.begin7_),
04490         end7_(other.end7_),
04491         current7_(other.current7_),
04492         begin8_(other.begin8_),
04493         end8_(other.end8_),
04494         current8_(other.current8_),
04495         begin9_(other.begin9_),
04496         end9_(other.end9_),
04497         current9_(other.current9_) {
04498       ComputeCurrentValue();
04499     }
04500 
04501     void ComputeCurrentValue() {
04502       if (!AtEnd())
04503         current_value_ = ParamType(*current1_, *current2_, *current3_,
04504             *current4_, *current5_, *current6_, *current7_, *current8_,
04505             *current9_);
04506     }
04507     bool AtEnd() const {
04508       // We must report iterator past the end of the range when either of the
04509       // component iterators has reached the end of its range.
04510       return
04511           current1_ == end1_ ||
04512           current2_ == end2_ ||
04513           current3_ == end3_ ||
04514           current4_ == end4_ ||
04515           current5_ == end5_ ||
04516           current6_ == end6_ ||
04517           current7_ == end7_ ||
04518           current8_ == end8_ ||
04519           current9_ == end9_;
04520     }
04521 
04522     // No implementation - assignment is unsupported.
04523     void operator=(const Iterator& other);
04524 
04525     const ParamGeneratorInterface<ParamType>* const base_;
04526     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
04527     // current[i]_ is the actual traversing iterator.
04528     const typename ParamGenerator<T1>::iterator begin1_;
04529     const typename ParamGenerator<T1>::iterator end1_;
04530     typename ParamGenerator<T1>::iterator current1_;
04531     const typename ParamGenerator<T2>::iterator begin2_;
04532     const typename ParamGenerator<T2>::iterator end2_;
04533     typename ParamGenerator<T2>::iterator current2_;
04534     const typename ParamGenerator<T3>::iterator begin3_;
04535     const typename ParamGenerator<T3>::iterator end3_;
04536     typename ParamGenerator<T3>::iterator current3_;
04537     const typename ParamGenerator<T4>::iterator begin4_;
04538     const typename ParamGenerator<T4>::iterator end4_;
04539     typename ParamGenerator<T4>::iterator current4_;
04540     const typename ParamGenerator<T5>::iterator begin5_;
04541     const typename ParamGenerator<T5>::iterator end5_;
04542     typename ParamGenerator<T5>::iterator current5_;
04543     const typename ParamGenerator<T6>::iterator begin6_;
04544     const typename ParamGenerator<T6>::iterator end6_;
04545     typename ParamGenerator<T6>::iterator current6_;
04546     const typename ParamGenerator<T7>::iterator begin7_;
04547     const typename ParamGenerator<T7>::iterator end7_;
04548     typename ParamGenerator<T7>::iterator current7_;
04549     const typename ParamGenerator<T8>::iterator begin8_;
04550     const typename ParamGenerator<T8>::iterator end8_;
04551     typename ParamGenerator<T8>::iterator current8_;
04552     const typename ParamGenerator<T9>::iterator begin9_;
04553     const typename ParamGenerator<T9>::iterator end9_;
04554     typename ParamGenerator<T9>::iterator current9_;
04555     ParamType current_value_;
04556   };  // class CartesianProductGenerator9::Iterator
04557 
04558   // No implementation - assignment is unsupported.
04559   void operator=(const CartesianProductGenerator9& other);
04560 
04561   const ParamGenerator<T1> g1_;
04562   const ParamGenerator<T2> g2_;
04563   const ParamGenerator<T3> g3_;
04564   const ParamGenerator<T4> g4_;
04565   const ParamGenerator<T5> g5_;
04566   const ParamGenerator<T6> g6_;
04567   const ParamGenerator<T7> g7_;
04568   const ParamGenerator<T8> g8_;
04569   const ParamGenerator<T9> g9_;
04570 };  // class CartesianProductGenerator9
04571 
04572 
04573 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04574     typename T6, typename T7, typename T8, typename T9, typename T10>
04575 class CartesianProductGenerator10
04576     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
04577         T7, T8, T9, T10> > {
04578  public:
04579   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ParamType;
04580 
04581   CartesianProductGenerator10(const ParamGenerator<T1>& g1,
04582       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
04583       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
04584       const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
04585       const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9,
04586       const ParamGenerator<T10>& g10)
04587       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
04588           g9_(g9), g10_(g10) {}
04589   virtual ~CartesianProductGenerator10() {}
04590 
04591   virtual ParamIteratorInterface<ParamType>* Begin() const {
04592     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
04593         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
04594         g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin(), g10_, g10_.begin());
04595   }
04596   virtual ParamIteratorInterface<ParamType>* End() const {
04597     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
04598         g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
04599         g8_.end(), g9_, g9_.end(), g10_, g10_.end());
04600   }
04601 
04602  private:
04603   class Iterator : public ParamIteratorInterface<ParamType> {
04604    public:
04605     Iterator(const ParamGeneratorInterface<ParamType>* base,
04606       const ParamGenerator<T1>& g1,
04607       const typename ParamGenerator<T1>::iterator& current1,
04608       const ParamGenerator<T2>& g2,
04609       const typename ParamGenerator<T2>::iterator& current2,
04610       const ParamGenerator<T3>& g3,
04611       const typename ParamGenerator<T3>::iterator& current3,
04612       const ParamGenerator<T4>& g4,
04613       const typename ParamGenerator<T4>::iterator& current4,
04614       const ParamGenerator<T5>& g5,
04615       const typename ParamGenerator<T5>::iterator& current5,
04616       const ParamGenerator<T6>& g6,
04617       const typename ParamGenerator<T6>::iterator& current6,
04618       const ParamGenerator<T7>& g7,
04619       const typename ParamGenerator<T7>::iterator& current7,
04620       const ParamGenerator<T8>& g8,
04621       const typename ParamGenerator<T8>::iterator& current8,
04622       const ParamGenerator<T9>& g9,
04623       const typename ParamGenerator<T9>::iterator& current9,
04624       const ParamGenerator<T10>& g10,
04625       const typename ParamGenerator<T10>::iterator& current10)
04626         : base_(base),
04627           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
04628           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
04629           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
04630           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
04631           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
04632           begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
04633           begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
04634           begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
04635           begin9_(g9.begin()), end9_(g9.end()), current9_(current9),
04636           begin10_(g10.begin()), end10_(g10.end()), current10_(current10)    {
04637       ComputeCurrentValue();
04638     }
04639     virtual ~Iterator() {}
04640 
04641     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
04642       return base_;
04643     }
04644     // Advance should not be called on beyond-of-range iterators
04645     // so no component iterators must be beyond end of range, either.
04646     virtual void Advance() {
04647       assert(!AtEnd());
04648       ++current10_;
04649       if (current10_ == end10_) {
04650         current10_ = begin10_;
04651         ++current9_;
04652       }
04653       if (current9_ == end9_) {
04654         current9_ = begin9_;
04655         ++current8_;
04656       }
04657       if (current8_ == end8_) {
04658         current8_ = begin8_;
04659         ++current7_;
04660       }
04661       if (current7_ == end7_) {
04662         current7_ = begin7_;
04663         ++current6_;
04664       }
04665       if (current6_ == end6_) {
04666         current6_ = begin6_;
04667         ++current5_;
04668       }
04669       if (current5_ == end5_) {
04670         current5_ = begin5_;
04671         ++current4_;
04672       }
04673       if (current4_ == end4_) {
04674         current4_ = begin4_;
04675         ++current3_;
04676       }
04677       if (current3_ == end3_) {
04678         current3_ = begin3_;
04679         ++current2_;
04680       }
04681       if (current2_ == end2_) {
04682         current2_ = begin2_;
04683         ++current1_;
04684       }
04685       ComputeCurrentValue();
04686     }
04687     virtual ParamIteratorInterface<ParamType>* Clone() const {
04688       return new Iterator(*this);
04689     }
04690     virtual const ParamType* Current() const { return &current_value_; }
04691     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
04692       // Having the same base generator guarantees that the other
04693       // iterator is of the same type and we can downcast.
04694       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
04695           << "The program attempted to compare iterators "
04696           << "from different generators." << std::endl;
04697       const Iterator* typed_other =
04698           CheckedDowncastToActualType<const Iterator>(&other);
04699       // We must report iterators equal if they both point beyond their
04700       // respective ranges. That can happen in a variety of fashions,
04701       // so we have to consult AtEnd().
04702       return (AtEnd() && typed_other->AtEnd()) ||
04703          (
04704           current1_ == typed_other->current1_ &&
04705           current2_ == typed_other->current2_ &&
04706           current3_ == typed_other->current3_ &&
04707           current4_ == typed_other->current4_ &&
04708           current5_ == typed_other->current5_ &&
04709           current6_ == typed_other->current6_ &&
04710           current7_ == typed_other->current7_ &&
04711           current8_ == typed_other->current8_ &&
04712           current9_ == typed_other->current9_ &&
04713           current10_ == typed_other->current10_);
04714     }
04715 
04716    private:
04717     Iterator(const Iterator& other)
04718         : base_(other.base_),
04719         begin1_(other.begin1_),
04720         end1_(other.end1_),
04721         current1_(other.current1_),
04722         begin2_(other.begin2_),
04723         end2_(other.end2_),
04724         current2_(other.current2_),
04725         begin3_(other.begin3_),
04726         end3_(other.end3_),
04727         current3_(other.current3_),
04728         begin4_(other.begin4_),
04729         end4_(other.end4_),
04730         current4_(other.current4_),
04731         begin5_(other.begin5_),
04732         end5_(other.end5_),
04733         current5_(other.current5_),
04734         begin6_(other.begin6_),
04735         end6_(other.end6_),
04736         current6_(other.current6_),
04737         begin7_(other.begin7_),
04738         end7_(other.end7_),
04739         current7_(other.current7_),
04740         begin8_(other.begin8_),
04741         end8_(other.end8_),
04742         current8_(other.current8_),
04743         begin9_(other.begin9_),
04744         end9_(other.end9_),
04745         current9_(other.current9_),
04746         begin10_(other.begin10_),
04747         end10_(other.end10_),
04748         current10_(other.current10_) {
04749       ComputeCurrentValue();
04750     }
04751 
04752     void ComputeCurrentValue() {
04753       if (!AtEnd())
04754         current_value_ = ParamType(*current1_, *current2_, *current3_,
04755             *current4_, *current5_, *current6_, *current7_, *current8_,
04756             *current9_, *current10_);
04757     }
04758     bool AtEnd() const {
04759       // We must report iterator past the end of the range when either of the
04760       // component iterators has reached the end of its range.
04761       return
04762           current1_ == end1_ ||
04763           current2_ == end2_ ||
04764           current3_ == end3_ ||
04765           current4_ == end4_ ||
04766           current5_ == end5_ ||
04767           current6_ == end6_ ||
04768           current7_ == end7_ ||
04769           current8_ == end8_ ||
04770           current9_ == end9_ ||
04771           current10_ == end10_;
04772     }
04773 
04774     // No implementation - assignment is unsupported.
04775     void operator=(const Iterator& other);
04776 
04777     const ParamGeneratorInterface<ParamType>* const base_;
04778     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
04779     // current[i]_ is the actual traversing iterator.
04780     const typename ParamGenerator<T1>::iterator begin1_;
04781     const typename ParamGenerator<T1>::iterator end1_;
04782     typename ParamGenerator<T1>::iterator current1_;
04783     const typename ParamGenerator<T2>::iterator begin2_;
04784     const typename ParamGenerator<T2>::iterator end2_;
04785     typename ParamGenerator<T2>::iterator current2_;
04786     const typename ParamGenerator<T3>::iterator begin3_;
04787     const typename ParamGenerator<T3>::iterator end3_;
04788     typename ParamGenerator<T3>::iterator current3_;
04789     const typename ParamGenerator<T4>::iterator begin4_;
04790     const typename ParamGenerator<T4>::iterator end4_;
04791     typename ParamGenerator<T4>::iterator current4_;
04792     const typename ParamGenerator<T5>::iterator begin5_;
04793     const typename ParamGenerator<T5>::iterator end5_;
04794     typename ParamGenerator<T5>::iterator current5_;
04795     const typename ParamGenerator<T6>::iterator begin6_;
04796     const typename ParamGenerator<T6>::iterator end6_;
04797     typename ParamGenerator<T6>::iterator current6_;
04798     const typename ParamGenerator<T7>::iterator begin7_;
04799     const typename ParamGenerator<T7>::iterator end7_;
04800     typename ParamGenerator<T7>::iterator current7_;
04801     const typename ParamGenerator<T8>::iterator begin8_;
04802     const typename ParamGenerator<T8>::iterator end8_;
04803     typename ParamGenerator<T8>::iterator current8_;
04804     const typename ParamGenerator<T9>::iterator begin9_;
04805     const typename ParamGenerator<T9>::iterator end9_;
04806     typename ParamGenerator<T9>::iterator current9_;
04807     const typename ParamGenerator<T10>::iterator begin10_;
04808     const typename ParamGenerator<T10>::iterator end10_;
04809     typename ParamGenerator<T10>::iterator current10_;
04810     ParamType current_value_;
04811   };  // class CartesianProductGenerator10::Iterator
04812 
04813   // No implementation - assignment is unsupported.
04814   void operator=(const CartesianProductGenerator10& other);
04815 
04816   const ParamGenerator<T1> g1_;
04817   const ParamGenerator<T2> g2_;
04818   const ParamGenerator<T3> g3_;
04819   const ParamGenerator<T4> g4_;
04820   const ParamGenerator<T5> g5_;
04821   const ParamGenerator<T6> g6_;
04822   const ParamGenerator<T7> g7_;
04823   const ParamGenerator<T8> g8_;
04824   const ParamGenerator<T9> g9_;
04825   const ParamGenerator<T10> g10_;
04826 };  // class CartesianProductGenerator10
04827 
04828 
04829 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
04830 //
04831 // Helper classes providing Combine() with polymorphic features. They allow
04832 // casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is
04833 // convertible to U.
04834 //
04835 template <class Generator1, class Generator2>
04836 class CartesianProductHolder2 {
04837  public:
04838 CartesianProductHolder2(const Generator1& g1, const Generator2& g2)
04839       : g1_(g1), g2_(g2) {}
04840   template <typename T1, typename T2>
04841   operator ParamGenerator< ::std::tr1::tuple<T1, T2> >() const {
04842     return ParamGenerator< ::std::tr1::tuple<T1, T2> >(
04843         new CartesianProductGenerator2<T1, T2>(
04844         static_cast<ParamGenerator<T1> >(g1_),
04845         static_cast<ParamGenerator<T2> >(g2_)));
04846   }
04847 
04848  private:
04849   // No implementation - assignment is unsupported.
04850   void operator=(const CartesianProductHolder2& other);
04851 
04852   const Generator1 g1_;
04853   const Generator2 g2_;
04854 };  // class CartesianProductHolder2
04855 
04856 template <class Generator1, class Generator2, class Generator3>
04857 class CartesianProductHolder3 {
04858  public:
04859 CartesianProductHolder3(const Generator1& g1, const Generator2& g2,
04860     const Generator3& g3)
04861       : g1_(g1), g2_(g2), g3_(g3) {}
04862   template <typename T1, typename T2, typename T3>
04863   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3> >() const {
04864     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3> >(
04865         new CartesianProductGenerator3<T1, T2, T3>(
04866         static_cast<ParamGenerator<T1> >(g1_),
04867         static_cast<ParamGenerator<T2> >(g2_),
04868         static_cast<ParamGenerator<T3> >(g3_)));
04869   }
04870 
04871  private:
04872   // No implementation - assignment is unsupported.
04873   void operator=(const CartesianProductHolder3& other);
04874 
04875   const Generator1 g1_;
04876   const Generator2 g2_;
04877   const Generator3 g3_;
04878 };  // class CartesianProductHolder3
04879 
04880 template <class Generator1, class Generator2, class Generator3,
04881     class Generator4>
04882 class CartesianProductHolder4 {
04883  public:
04884 CartesianProductHolder4(const Generator1& g1, const Generator2& g2,
04885     const Generator3& g3, const Generator4& g4)
04886       : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
04887   template <typename T1, typename T2, typename T3, typename T4>
04888   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4> >() const {
04889     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4> >(
04890         new CartesianProductGenerator4<T1, T2, T3, T4>(
04891         static_cast<ParamGenerator<T1> >(g1_),
04892         static_cast<ParamGenerator<T2> >(g2_),
04893         static_cast<ParamGenerator<T3> >(g3_),
04894         static_cast<ParamGenerator<T4> >(g4_)));
04895   }
04896 
04897  private:
04898   // No implementation - assignment is unsupported.
04899   void operator=(const CartesianProductHolder4& other);
04900 
04901   const Generator1 g1_;
04902   const Generator2 g2_;
04903   const Generator3 g3_;
04904   const Generator4 g4_;
04905 };  // class CartesianProductHolder4
04906 
04907 template <class Generator1, class Generator2, class Generator3,
04908     class Generator4, class Generator5>
04909 class CartesianProductHolder5 {
04910  public:
04911 CartesianProductHolder5(const Generator1& g1, const Generator2& g2,
04912     const Generator3& g3, const Generator4& g4, const Generator5& g5)
04913       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
04914   template <typename T1, typename T2, typename T3, typename T4, typename T5>
04915   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5> >() const {
04916     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5> >(
04917         new CartesianProductGenerator5<T1, T2, T3, T4, T5>(
04918         static_cast<ParamGenerator<T1> >(g1_),
04919         static_cast<ParamGenerator<T2> >(g2_),
04920         static_cast<ParamGenerator<T3> >(g3_),
04921         static_cast<ParamGenerator<T4> >(g4_),
04922         static_cast<ParamGenerator<T5> >(g5_)));
04923   }
04924 
04925  private:
04926   // No implementation - assignment is unsupported.
04927   void operator=(const CartesianProductHolder5& other);
04928 
04929   const Generator1 g1_;
04930   const Generator2 g2_;
04931   const Generator3 g3_;
04932   const Generator4 g4_;
04933   const Generator5 g5_;
04934 };  // class CartesianProductHolder5
04935 
04936 template <class Generator1, class Generator2, class Generator3,
04937     class Generator4, class Generator5, class Generator6>
04938 class CartesianProductHolder6 {
04939  public:
04940 CartesianProductHolder6(const Generator1& g1, const Generator2& g2,
04941     const Generator3& g3, const Generator4& g4, const Generator5& g5,
04942     const Generator6& g6)
04943       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
04944   template <typename T1, typename T2, typename T3, typename T4, typename T5,
04945       typename T6>
04946   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> >() const {
04947     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> >(
04948         new CartesianProductGenerator6<T1, T2, T3, T4, T5, T6>(
04949         static_cast<ParamGenerator<T1> >(g1_),
04950         static_cast<ParamGenerator<T2> >(g2_),
04951         static_cast<ParamGenerator<T3> >(g3_),
04952         static_cast<ParamGenerator<T4> >(g4_),
04953         static_cast<ParamGenerator<T5> >(g5_),
04954         static_cast<ParamGenerator<T6> >(g6_)));
04955   }
04956 
04957  private:
04958   // No implementation - assignment is unsupported.
04959   void operator=(const CartesianProductHolder6& other);
04960 
04961   const Generator1 g1_;
04962   const Generator2 g2_;
04963   const Generator3 g3_;
04964   const Generator4 g4_;
04965   const Generator5 g5_;
04966   const Generator6 g6_;
04967 };  // class CartesianProductHolder6
04968 
04969 template <class Generator1, class Generator2, class Generator3,
04970     class Generator4, class Generator5, class Generator6, class Generator7>
04971 class CartesianProductHolder7 {
04972  public:
04973 CartesianProductHolder7(const Generator1& g1, const Generator2& g2,
04974     const Generator3& g3, const Generator4& g4, const Generator5& g5,
04975     const Generator6& g6, const Generator7& g7)
04976       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
04977   template <typename T1, typename T2, typename T3, typename T4, typename T5,
04978       typename T6, typename T7>
04979   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
04980       T7> >() const {
04981     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7> >(
04982         new CartesianProductGenerator7<T1, T2, T3, T4, T5, T6, T7>(
04983         static_cast<ParamGenerator<T1> >(g1_),
04984         static_cast<ParamGenerator<T2> >(g2_),
04985         static_cast<ParamGenerator<T3> >(g3_),
04986         static_cast<ParamGenerator<T4> >(g4_),
04987         static_cast<ParamGenerator<T5> >(g5_),
04988         static_cast<ParamGenerator<T6> >(g6_),
04989         static_cast<ParamGenerator<T7> >(g7_)));
04990   }
04991 
04992  private:
04993   // No implementation - assignment is unsupported.
04994   void operator=(const CartesianProductHolder7& other);
04995 
04996   const Generator1 g1_;
04997   const Generator2 g2_;
04998   const Generator3 g3_;
04999   const Generator4 g4_;
05000   const Generator5 g5_;
05001   const Generator6 g6_;
05002   const Generator7 g7_;
05003 };  // class CartesianProductHolder7
05004 
05005 template <class Generator1, class Generator2, class Generator3,
05006     class Generator4, class Generator5, class Generator6, class Generator7,
05007     class Generator8>
05008 class CartesianProductHolder8 {
05009  public:
05010 CartesianProductHolder8(const Generator1& g1, const Generator2& g2,
05011     const Generator3& g3, const Generator4& g4, const Generator5& g5,
05012     const Generator6& g6, const Generator7& g7, const Generator8& g8)
05013       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
05014           g8_(g8) {}
05015   template <typename T1, typename T2, typename T3, typename T4, typename T5,
05016       typename T6, typename T7, typename T8>
05017   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7,
05018       T8> >() const {
05019     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8> >(
05020         new CartesianProductGenerator8<T1, T2, T3, T4, T5, T6, T7, T8>(
05021         static_cast<ParamGenerator<T1> >(g1_),
05022         static_cast<ParamGenerator<T2> >(g2_),
05023         static_cast<ParamGenerator<T3> >(g3_),
05024         static_cast<ParamGenerator<T4> >(g4_),
05025         static_cast<ParamGenerator<T5> >(g5_),
05026         static_cast<ParamGenerator<T6> >(g6_),
05027         static_cast<ParamGenerator<T7> >(g7_),
05028         static_cast<ParamGenerator<T8> >(g8_)));
05029   }
05030 
05031  private:
05032   // No implementation - assignment is unsupported.
05033   void operator=(const CartesianProductHolder8& other);
05034 
05035   const Generator1 g1_;
05036   const Generator2 g2_;
05037   const Generator3 g3_;
05038   const Generator4 g4_;
05039   const Generator5 g5_;
05040   const Generator6 g6_;
05041   const Generator7 g7_;
05042   const Generator8 g8_;
05043 };  // class CartesianProductHolder8
05044 
05045 template <class Generator1, class Generator2, class Generator3,
05046     class Generator4, class Generator5, class Generator6, class Generator7,
05047     class Generator8, class Generator9>
05048 class CartesianProductHolder9 {
05049  public:
05050 CartesianProductHolder9(const Generator1& g1, const Generator2& g2,
05051     const Generator3& g3, const Generator4& g4, const Generator5& g5,
05052     const Generator6& g6, const Generator7& g7, const Generator8& g8,
05053     const Generator9& g9)
05054       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
05055           g9_(g9) {}
05056   template <typename T1, typename T2, typename T3, typename T4, typename T5,
05057       typename T6, typename T7, typename T8, typename T9>
05058   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
05059       T9> >() const {
05060     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
05061         T9> >(
05062         new CartesianProductGenerator9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
05063         static_cast<ParamGenerator<T1> >(g1_),
05064         static_cast<ParamGenerator<T2> >(g2_),
05065         static_cast<ParamGenerator<T3> >(g3_),
05066         static_cast<ParamGenerator<T4> >(g4_),
05067         static_cast<ParamGenerator<T5> >(g5_),
05068         static_cast<ParamGenerator<T6> >(g6_),
05069         static_cast<ParamGenerator<T7> >(g7_),
05070         static_cast<ParamGenerator<T8> >(g8_),
05071         static_cast<ParamGenerator<T9> >(g9_)));
05072   }
05073 
05074  private:
05075   // No implementation - assignment is unsupported.
05076   void operator=(const CartesianProductHolder9& other);
05077 
05078   const Generator1 g1_;
05079   const Generator2 g2_;
05080   const Generator3 g3_;
05081   const Generator4 g4_;
05082   const Generator5 g5_;
05083   const Generator6 g6_;
05084   const Generator7 g7_;
05085   const Generator8 g8_;
05086   const Generator9 g9_;
05087 };  // class CartesianProductHolder9
05088 
05089 template <class Generator1, class Generator2, class Generator3,
05090     class Generator4, class Generator5, class Generator6, class Generator7,
05091     class Generator8, class Generator9, class Generator10>
05092 class CartesianProductHolder10 {
05093  public:
05094 CartesianProductHolder10(const Generator1& g1, const Generator2& g2,
05095     const Generator3& g3, const Generator4& g4, const Generator5& g5,
05096     const Generator6& g6, const Generator7& g7, const Generator8& g8,
05097     const Generator9& g9, const Generator10& g10)
05098       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
05099           g9_(g9), g10_(g10) {}
05100   template <typename T1, typename T2, typename T3, typename T4, typename T5,
05101       typename T6, typename T7, typename T8, typename T9, typename T10>
05102   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
05103       T9, T10> >() const {
05104     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
05105         T9, T10> >(
05106         new CartesianProductGenerator10<T1, T2, T3, T4, T5, T6, T7, T8, T9,
05107             T10>(
05108         static_cast<ParamGenerator<T1> >(g1_),
05109         static_cast<ParamGenerator<T2> >(g2_),
05110         static_cast<ParamGenerator<T3> >(g3_),
05111         static_cast<ParamGenerator<T4> >(g4_),
05112         static_cast<ParamGenerator<T5> >(g5_),
05113         static_cast<ParamGenerator<T6> >(g6_),
05114         static_cast<ParamGenerator<T7> >(g7_),
05115         static_cast<ParamGenerator<T8> >(g8_),
05116         static_cast<ParamGenerator<T9> >(g9_),
05117         static_cast<ParamGenerator<T10> >(g10_)));
05118   }
05119 
05120  private:
05121   // No implementation - assignment is unsupported.
05122   void operator=(const CartesianProductHolder10& other);
05123 
05124   const Generator1 g1_;
05125   const Generator2 g2_;
05126   const Generator3 g3_;
05127   const Generator4 g4_;
05128   const Generator5 g5_;
05129   const Generator6 g6_;
05130   const Generator7 g7_;
05131   const Generator8 g8_;
05132   const Generator9 g9_;
05133   const Generator10 g10_;
05134 };  // class CartesianProductHolder10
05135 
05136 # endif  // GTEST_HAS_COMBINE
05137 
05138 }  // namespace internal
05139 }  // namespace testing
05140 
05141 #endif  //  GTEST_HAS_PARAM_TEST
05142 
05143 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_