Qucs-core
0.0.19
|
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 ¤t_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 ¤t_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 ¤t_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 ¤t_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 ¤t_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 ¤t_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 ¤t_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 ¤t_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 ¤t_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_