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