1 // This file was GENERATED by command: 2 // pump.py gtest-tuple.h.pump 3 // DO NOT EDIT BY HAND!!! 4 5 // Copyright 2009 Google Inc. 6 // All Rights Reserved. 7 // 8 // Redistribution and use in source and binary forms, with or without 9 // modification, are permitted provided that the following conditions are 10 // met: 11 // 12 // * Redistributions of source code must retain the above copyright 13 // notice, this list of conditions and the following disclaimer. 14 // * Redistributions in binary form must reproduce the above 15 // copyright notice, this list of conditions and the following disclaimer 16 // in the documentation and/or other materials provided with the 17 // distribution. 18 // * Neither the name of Google Inc. nor the names of its 19 // contributors may be used to endorse or promote products derived from 20 // this software without specific prior written permission. 21 // 22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 25 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 26 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 27 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 28 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 32 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 // 34 // Author: wan (at) google.com (Zhanyong Wan) 35 36 // Implements a subset of TR1 tuple needed by Google Test and Google Mock. 37 38 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ 39 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ 40 41 #include <utility> // For ::std::pair. 42 43 // The compiler used in Symbian has a bug that prevents us from declaring the 44 // tuple template as a friend (it complains that tuple is redefined). This 45 // hack bypasses the bug by declaring the members that should otherwise be 46 // private as public. 47 // Sun Studio versions < 12 also have the above bug. 48 #if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590) 49 # define GTEST_DECLARE_TUPLE_AS_FRIEND_ public: 50 #else 51 # define GTEST_DECLARE_TUPLE_AS_FRIEND_ \ 52 template <GTEST_10_TYPENAMES_(U)> friend class tuple; \ 53 private: 54 #endif 55 56 // GTEST_n_TUPLE_(T) is the type of an n-tuple. 57 #define GTEST_0_TUPLE_(T) tuple<> 58 #define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \ 59 void, void, void> 60 #define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \ 61 void, void, void> 62 #define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \ 63 void, void, void> 64 #define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \ 65 void, void, void> 66 #define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \ 67 void, void, void> 68 #define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \ 69 void, void, void> 70 #define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ 71 void, void, void> 72 #define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ 73 T##7, void, void> 74 #define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ 75 T##7, T##8, void> 76 #define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ 77 T##7, T##8, T##9> 78 79 // GTEST_n_TYPENAMES_(T) declares a list of n typenames. 80 #define GTEST_0_TYPENAMES_(T) 81 #define GTEST_1_TYPENAMES_(T) typename T##0 82 #define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1 83 #define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2 84 #define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ 85 typename T##3 86 #define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ 87 typename T##3, typename T##4 88 #define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ 89 typename T##3, typename T##4, typename T##5 90 #define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ 91 typename T##3, typename T##4, typename T##5, typename T##6 92 #define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ 93 typename T##3, typename T##4, typename T##5, typename T##6, typename T##7 94 #define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ 95 typename T##3, typename T##4, typename T##5, typename T##6, \ 96 typename T##7, typename T##8 97 #define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ 98 typename T##3, typename T##4, typename T##5, typename T##6, \ 99 typename T##7, typename T##8, typename T##9 100 101 // In theory, defining stuff in the ::std namespace is undefined 102 // behavior. We can do this as we are playing the role of a standard 103 // library vendor. 104 namespace std { 105 namespace tr1 { 106 107 template <typename T0 = void, typename T1 = void, typename T2 = void, 108 typename T3 = void, typename T4 = void, typename T5 = void, 109 typename T6 = void, typename T7 = void, typename T8 = void, 110 typename T9 = void> 111 class tuple; 112 113 // Anything in namespace gtest_internal is Google Test's INTERNAL 114 // IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code. 115 namespace gtest_internal { 116 117 // ByRef<T>::type is T if T is a reference; otherwise it's const T&. 118 template <typename T> 119 struct ByRef { typedef const T& type; }; // NOLINT 120 template <typename T> 121 struct ByRef<T&> { typedef T& type; }; // NOLINT 122 123 // A handy wrapper for ByRef. 124 #define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type 125 126 // AddRef<T>::type is T if T is a reference; otherwise it's T&. This 127 // is the same as tr1::add_reference<T>::type. 128 template <typename T> 129 struct AddRef { typedef T& type; }; // NOLINT 130 template <typename T> 131 struct AddRef<T&> { typedef T& type; }; // NOLINT 132 133 // A handy wrapper for AddRef. 134 #define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type 135 136 // A helper for implementing get<k>(). 137 template <int k> class Get; 138 139 // A helper for implementing tuple_element<k, T>. kIndexValid is true 140 // iff k < the number of fields in tuple type T. 141 template <bool kIndexValid, int kIndex, class Tuple> 142 struct TupleElement; 143 144 template <GTEST_10_TYPENAMES_(T)> 145 struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > { 146 typedef T0 type; 147 }; 148 149 template <GTEST_10_TYPENAMES_(T)> 150 struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > { 151 typedef T1 type; 152 }; 153 154 template <GTEST_10_TYPENAMES_(T)> 155 struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > { 156 typedef T2 type; 157 }; 158 159 template <GTEST_10_TYPENAMES_(T)> 160 struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > { 161 typedef T3 type; 162 }; 163 164 template <GTEST_10_TYPENAMES_(T)> 165 struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > { 166 typedef T4 type; 167 }; 168 169 template <GTEST_10_TYPENAMES_(T)> 170 struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > { 171 typedef T5 type; 172 }; 173 174 template <GTEST_10_TYPENAMES_(T)> 175 struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > { 176 typedef T6 type; 177 }; 178 179 template <GTEST_10_TYPENAMES_(T)> 180 struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > { 181 typedef T7 type; 182 }; 183 184 template <GTEST_10_TYPENAMES_(T)> 185 struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > { 186 typedef T8 type; 187 }; 188 189 template <GTEST_10_TYPENAMES_(T)> 190 struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > { 191 typedef T9 type; 192 }; 193 194 } // namespace gtest_internal 195 196 template <> 197 class tuple<> { 198 public: 199 tuple() {} 200 tuple(const tuple& /* t */) {} 201 tuple& operator=(const tuple& /* t */) { return *this; } 202 }; 203 204 template <GTEST_1_TYPENAMES_(T)> 205 class GTEST_1_TUPLE_(T) { 206 public: 207 template <int k> friend class gtest_internal::Get; 208 209 tuple() : f0_() {} 210 211 explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {} 212 213 tuple(const tuple& t) : f0_(t.f0_) {} 214 215 template <GTEST_1_TYPENAMES_(U)> 216 tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {} 217 218 tuple& operator=(const tuple& t) { return CopyFrom(t); } 219 220 template <GTEST_1_TYPENAMES_(U)> 221 tuple& operator=(const GTEST_1_TUPLE_(U)& t) { 222 return CopyFrom(t); 223 } 224 225 GTEST_DECLARE_TUPLE_AS_FRIEND_ 226 227 template <GTEST_1_TYPENAMES_(U)> 228 tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) { 229 f0_ = t.f0_; 230 return *this; 231 } 232 233 T0 f0_; 234 }; 235 236 template <GTEST_2_TYPENAMES_(T)> 237 class GTEST_2_TUPLE_(T) { 238 public: 239 template <int k> friend class gtest_internal::Get; 240 241 tuple() : f0_(), f1_() {} 242 243 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0), 244 f1_(f1) {} 245 246 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {} 247 248 template <GTEST_2_TYPENAMES_(U)> 249 tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {} 250 template <typename U0, typename U1> 251 tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {} 252 253 tuple& operator=(const tuple& t) { return CopyFrom(t); } 254 255 template <GTEST_2_TYPENAMES_(U)> 256 tuple& operator=(const GTEST_2_TUPLE_(U)& t) { 257 return CopyFrom(t); 258 } 259 template <typename U0, typename U1> 260 tuple& operator=(const ::std::pair<U0, U1>& p) { 261 f0_ = p.first; 262 f1_ = p.second; 263 return *this; 264 } 265 266 GTEST_DECLARE_TUPLE_AS_FRIEND_ 267 268 template <GTEST_2_TYPENAMES_(U)> 269 tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) { 270 f0_ = t.f0_; 271 f1_ = t.f1_; 272 return *this; 273 } 274 275 T0 f0_; 276 T1 f1_; 277 }; 278 279 template <GTEST_3_TYPENAMES_(T)> 280 class GTEST_3_TUPLE_(T) { 281 public: 282 template <int k> friend class gtest_internal::Get; 283 284 tuple() : f0_(), f1_(), f2_() {} 285 286 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, 287 GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {} 288 289 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {} 290 291 template <GTEST_3_TYPENAMES_(U)> 292 tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {} 293 294 tuple& operator=(const tuple& t) { return CopyFrom(t); } 295 296 template <GTEST_3_TYPENAMES_(U)> 297 tuple& operator=(const GTEST_3_TUPLE_(U)& t) { 298 return CopyFrom(t); 299 } 300 301 GTEST_DECLARE_TUPLE_AS_FRIEND_ 302 303 template <GTEST_3_TYPENAMES_(U)> 304 tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) { 305 f0_ = t.f0_; 306 f1_ = t.f1_; 307 f2_ = t.f2_; 308 return *this; 309 } 310 311 T0 f0_; 312 T1 f1_; 313 T2 f2_; 314 }; 315 316 template <GTEST_4_TYPENAMES_(T)> 317 class GTEST_4_TUPLE_(T) { 318 public: 319 template <int k> friend class gtest_internal::Get; 320 321 tuple() : f0_(), f1_(), f2_(), f3_() {} 322 323 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, 324 GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2), 325 f3_(f3) {} 326 327 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {} 328 329 template <GTEST_4_TYPENAMES_(U)> 330 tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), 331 f3_(t.f3_) {} 332 333 tuple& operator=(const tuple& t) { return CopyFrom(t); } 334 335 template <GTEST_4_TYPENAMES_(U)> 336 tuple& operator=(const GTEST_4_TUPLE_(U)& t) { 337 return CopyFrom(t); 338 } 339 340 GTEST_DECLARE_TUPLE_AS_FRIEND_ 341 342 template <GTEST_4_TYPENAMES_(U)> 343 tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) { 344 f0_ = t.f0_; 345 f1_ = t.f1_; 346 f2_ = t.f2_; 347 f3_ = t.f3_; 348 return *this; 349 } 350 351 T0 f0_; 352 T1 f1_; 353 T2 f2_; 354 T3 f3_; 355 }; 356 357 template <GTEST_5_TYPENAMES_(T)> 358 class GTEST_5_TUPLE_(T) { 359 public: 360 template <int k> friend class gtest_internal::Get; 361 362 tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {} 363 364 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, 365 GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, 366 GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {} 367 368 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), 369 f4_(t.f4_) {} 370 371 template <GTEST_5_TYPENAMES_(U)> 372 tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), 373 f3_(t.f3_), f4_(t.f4_) {} 374 375 tuple& operator=(const tuple& t) { return CopyFrom(t); } 376 377 template <GTEST_5_TYPENAMES_(U)> 378 tuple& operator=(const GTEST_5_TUPLE_(U)& t) { 379 return CopyFrom(t); 380 } 381 382 GTEST_DECLARE_TUPLE_AS_FRIEND_ 383 384 template <GTEST_5_TYPENAMES_(U)> 385 tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) { 386 f0_ = t.f0_; 387 f1_ = t.f1_; 388 f2_ = t.f2_; 389 f3_ = t.f3_; 390 f4_ = t.f4_; 391 return *this; 392 } 393 394 T0 f0_; 395 T1 f1_; 396 T2 f2_; 397 T3 f3_; 398 T4 f4_; 399 }; 400 401 template <GTEST_6_TYPENAMES_(T)> 402 class GTEST_6_TUPLE_(T) { 403 public: 404 template <int k> friend class gtest_internal::Get; 405 406 tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {} 407 408 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, 409 GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, 410 GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), 411 f5_(f5) {} 412 413 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), 414 f4_(t.f4_), f5_(t.f5_) {} 415 416 template <GTEST_6_TYPENAMES_(U)> 417 tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), 418 f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {} 419 420 tuple& operator=(const tuple& t) { return CopyFrom(t); } 421 422 template <GTEST_6_TYPENAMES_(U)> 423 tuple& operator=(const GTEST_6_TUPLE_(U)& t) { 424 return CopyFrom(t); 425 } 426 427 GTEST_DECLARE_TUPLE_AS_FRIEND_ 428 429 template <GTEST_6_TYPENAMES_(U)> 430 tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) { 431 f0_ = t.f0_; 432 f1_ = t.f1_; 433 f2_ = t.f2_; 434 f3_ = t.f3_; 435 f4_ = t.f4_; 436 f5_ = t.f5_; 437 return *this; 438 } 439 440 T0 f0_; 441 T1 f1_; 442 T2 f2_; 443 T3 f3_; 444 T4 f4_; 445 T5 f5_; 446 }; 447 448 template <GTEST_7_TYPENAMES_(T)> 449 class GTEST_7_TUPLE_(T) { 450 public: 451 template <int k> friend class gtest_internal::Get; 452 453 tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {} 454 455 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, 456 GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, 457 GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2), 458 f3_(f3), f4_(f4), f5_(f5), f6_(f6) {} 459 460 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), 461 f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {} 462 463 template <GTEST_7_TYPENAMES_(U)> 464 tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), 465 f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {} 466 467 tuple& operator=(const tuple& t) { return CopyFrom(t); } 468 469 template <GTEST_7_TYPENAMES_(U)> 470 tuple& operator=(const GTEST_7_TUPLE_(U)& t) { 471 return CopyFrom(t); 472 } 473 474 GTEST_DECLARE_TUPLE_AS_FRIEND_ 475 476 template <GTEST_7_TYPENAMES_(U)> 477 tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) { 478 f0_ = t.f0_; 479 f1_ = t.f1_; 480 f2_ = t.f2_; 481 f3_ = t.f3_; 482 f4_ = t.f4_; 483 f5_ = t.f5_; 484 f6_ = t.f6_; 485 return *this; 486 } 487 488 T0 f0_; 489 T1 f1_; 490 T2 f2_; 491 T3 f3_; 492 T4 f4_; 493 T5 f5_; 494 T6 f6_; 495 }; 496 497 template <GTEST_8_TYPENAMES_(T)> 498 class GTEST_8_TUPLE_(T) { 499 public: 500 template <int k> friend class gtest_internal::Get; 501 502 tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {} 503 504 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, 505 GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, 506 GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, 507 GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), 508 f5_(f5), f6_(f6), f7_(f7) {} 509 510 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), 511 f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {} 512 513 template <GTEST_8_TYPENAMES_(U)> 514 tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), 515 f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {} 516 517 tuple& operator=(const tuple& t) { return CopyFrom(t); } 518 519 template <GTEST_8_TYPENAMES_(U)> 520 tuple& operator=(const GTEST_8_TUPLE_(U)& t) { 521 return CopyFrom(t); 522 } 523 524 GTEST_DECLARE_TUPLE_AS_FRIEND_ 525 526 template <GTEST_8_TYPENAMES_(U)> 527 tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) { 528 f0_ = t.f0_; 529 f1_ = t.f1_; 530 f2_ = t.f2_; 531 f3_ = t.f3_; 532 f4_ = t.f4_; 533 f5_ = t.f5_; 534 f6_ = t.f6_; 535 f7_ = t.f7_; 536 return *this; 537 } 538 539 T0 f0_; 540 T1 f1_; 541 T2 f2_; 542 T3 f3_; 543 T4 f4_; 544 T5 f5_; 545 T6 f6_; 546 T7 f7_; 547 }; 548 549 template <GTEST_9_TYPENAMES_(T)> 550 class GTEST_9_TUPLE_(T) { 551 public: 552 template <int k> friend class gtest_internal::Get; 553 554 tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {} 555 556 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, 557 GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, 558 GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7, 559 GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), 560 f5_(f5), f6_(f6), f7_(f7), f8_(f8) {} 561 562 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), 563 f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {} 564 565 template <GTEST_9_TYPENAMES_(U)> 566 tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), 567 f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {} 568 569 tuple& operator=(const tuple& t) { return CopyFrom(t); } 570 571 template <GTEST_9_TYPENAMES_(U)> 572 tuple& operator=(const GTEST_9_TUPLE_(U)& t) { 573 return CopyFrom(t); 574 } 575 576 GTEST_DECLARE_TUPLE_AS_FRIEND_ 577 578 template <GTEST_9_TYPENAMES_(U)> 579 tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) { 580 f0_ = t.f0_; 581 f1_ = t.f1_; 582 f2_ = t.f2_; 583 f3_ = t.f3_; 584 f4_ = t.f4_; 585 f5_ = t.f5_; 586 f6_ = t.f6_; 587 f7_ = t.f7_; 588 f8_ = t.f8_; 589 return *this; 590 } 591 592 T0 f0_; 593 T1 f1_; 594 T2 f2_; 595 T3 f3_; 596 T4 f4_; 597 T5 f5_; 598 T6 f6_; 599 T7 f7_; 600 T8 f8_; 601 }; 602 603 template <GTEST_10_TYPENAMES_(T)> 604 class tuple { 605 public: 606 template <int k> friend class gtest_internal::Get; 607 608 tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(), 609 f9_() {} 610 611 explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, 612 GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, 613 GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7, 614 GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2), 615 f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {} 616 617 tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), 618 f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {} 619 620 template <GTEST_10_TYPENAMES_(U)> 621 tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), 622 f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), 623 f9_(t.f9_) {} 624 625 tuple& operator=(const tuple& t) { return CopyFrom(t); } 626 627 template <GTEST_10_TYPENAMES_(U)> 628 tuple& operator=(const GTEST_10_TUPLE_(U)& t) { 629 return CopyFrom(t); 630 } 631 632 GTEST_DECLARE_TUPLE_AS_FRIEND_ 633 634 template <GTEST_10_TYPENAMES_(U)> 635 tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) { 636 f0_ = t.f0_; 637 f1_ = t.f1_; 638 f2_ = t.f2_; 639 f3_ = t.f3_; 640 f4_ = t.f4_; 641 f5_ = t.f5_; 642 f6_ = t.f6_; 643 f7_ = t.f7_; 644 f8_ = t.f8_; 645 f9_ = t.f9_; 646 return *this; 647 } 648 649 T0 f0_; 650 T1 f1_; 651 T2 f2_; 652 T3 f3_; 653 T4 f4_; 654 T5 f5_; 655 T6 f6_; 656 T7 f7_; 657 T8 f8_; 658 T9 f9_; 659 }; 660 661 // 6.1.3.2 Tuple creation functions. 662 663 // Known limitations: we don't support passing an 664 // std::tr1::reference_wrapper<T> to make_tuple(). And we don't 665 // implement tie(). 666 667 inline tuple<> make_tuple() { return tuple<>(); } 668 669 template <GTEST_1_TYPENAMES_(T)> 670 inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) { 671 return GTEST_1_TUPLE_(T)(f0); 672 } 673 674 template <GTEST_2_TYPENAMES_(T)> 675 inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) { 676 return GTEST_2_TUPLE_(T)(f0, f1); 677 } 678 679 template <GTEST_3_TYPENAMES_(T)> 680 inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) { 681 return GTEST_3_TUPLE_(T)(f0, f1, f2); 682 } 683 684 template <GTEST_4_TYPENAMES_(T)> 685 inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, 686 const T3& f3) { 687 return GTEST_4_TUPLE_(T)(f0, f1, f2, f3); 688 } 689 690 template <GTEST_5_TYPENAMES_(T)> 691 inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, 692 const T3& f3, const T4& f4) { 693 return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4); 694 } 695 696 template <GTEST_6_TYPENAMES_(T)> 697 inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, 698 const T3& f3, const T4& f4, const T5& f5) { 699 return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5); 700 } 701 702 template <GTEST_7_TYPENAMES_(T)> 703 inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, 704 const T3& f3, const T4& f4, const T5& f5, const T6& f6) { 705 return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6); 706 } 707 708 template <GTEST_8_TYPENAMES_(T)> 709 inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, 710 const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) { 711 return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7); 712 } 713 714 template <GTEST_9_TYPENAMES_(T)> 715 inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, 716 const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7, 717 const T8& f8) { 718 return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8); 719 } 720 721 template <GTEST_10_TYPENAMES_(T)> 722 inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, 723 const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7, 724 const T8& f8, const T9& f9) { 725 return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9); 726 } 727 728 // 6.1.3.3 Tuple helper classes. 729 730 template <typename Tuple> struct tuple_size; 731 732 template <GTEST_0_TYPENAMES_(T)> 733 struct tuple_size<GTEST_0_TUPLE_(T) > { 734 static const int value = 0; 735 }; 736 737 template <GTEST_1_TYPENAMES_(T)> 738 struct tuple_size<GTEST_1_TUPLE_(T) > { 739 static const int value = 1; 740 }; 741 742 template <GTEST_2_TYPENAMES_(T)> 743 struct tuple_size<GTEST_2_TUPLE_(T) > { 744 static const int value = 2; 745 }; 746 747 template <GTEST_3_TYPENAMES_(T)> 748 struct tuple_size<GTEST_3_TUPLE_(T) > { 749 static const int value = 3; 750 }; 751 752 template <GTEST_4_TYPENAMES_(T)> 753 struct tuple_size<GTEST_4_TUPLE_(T) > { 754 static const int value = 4; 755 }; 756 757 template <GTEST_5_TYPENAMES_(T)> 758 struct tuple_size<GTEST_5_TUPLE_(T) > { 759 static const int value = 5; 760 }; 761 762 template <GTEST_6_TYPENAMES_(T)> 763 struct tuple_size<GTEST_6_TUPLE_(T) > { 764 static const int value = 6; 765 }; 766 767 template <GTEST_7_TYPENAMES_(T)> 768 struct tuple_size<GTEST_7_TUPLE_(T) > { 769 static const int value = 7; 770 }; 771 772 template <GTEST_8_TYPENAMES_(T)> 773 struct tuple_size<GTEST_8_TUPLE_(T) > { 774 static const int value = 8; 775 }; 776 777 template <GTEST_9_TYPENAMES_(T)> 778 struct tuple_size<GTEST_9_TUPLE_(T) > { 779 static const int value = 9; 780 }; 781 782 template <GTEST_10_TYPENAMES_(T)> 783 struct tuple_size<GTEST_10_TUPLE_(T) > { 784 static const int value = 10; 785 }; 786 787 template <int k, class Tuple> 788 struct tuple_element { 789 typedef typename gtest_internal::TupleElement< 790 k < (tuple_size<Tuple>::value), k, Tuple>::type type; 791 }; 792 793 #define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type 794 795 // 6.1.3.4 Element access. 796 797 namespace gtest_internal { 798 799 template <> 800 class Get<0> { 801 public: 802 template <class Tuple> 803 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple)) 804 Field(Tuple& t) { return t.f0_; } // NOLINT 805 806 template <class Tuple> 807 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple)) 808 ConstField(const Tuple& t) { return t.f0_; } 809 }; 810 811 template <> 812 class Get<1> { 813 public: 814 template <class Tuple> 815 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple)) 816 Field(Tuple& t) { return t.f1_; } // NOLINT 817 818 template <class Tuple> 819 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple)) 820 ConstField(const Tuple& t) { return t.f1_; } 821 }; 822 823 template <> 824 class Get<2> { 825 public: 826 template <class Tuple> 827 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple)) 828 Field(Tuple& t) { return t.f2_; } // NOLINT 829 830 template <class Tuple> 831 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple)) 832 ConstField(const Tuple& t) { return t.f2_; } 833 }; 834 835 template <> 836 class Get<3> { 837 public: 838 template <class Tuple> 839 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple)) 840 Field(Tuple& t) { return t.f3_; } // NOLINT 841 842 template <class Tuple> 843 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple)) 844 ConstField(const Tuple& t) { return t.f3_; } 845 }; 846 847 template <> 848 class Get<4> { 849 public: 850 template <class Tuple> 851 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple)) 852 Field(Tuple& t) { return t.f4_; } // NOLINT 853 854 template <class Tuple> 855 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple)) 856 ConstField(const Tuple& t) { return t.f4_; } 857 }; 858 859 template <> 860 class Get<5> { 861 public: 862 template <class Tuple> 863 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple)) 864 Field(Tuple& t) { return t.f5_; } // NOLINT 865 866 template <class Tuple> 867 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple)) 868 ConstField(const Tuple& t) { return t.f5_; } 869 }; 870 871 template <> 872 class Get<6> { 873 public: 874 template <class Tuple> 875 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple)) 876 Field(Tuple& t) { return t.f6_; } // NOLINT 877 878 template <class Tuple> 879 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple)) 880 ConstField(const Tuple& t) { return t.f6_; } 881 }; 882 883 template <> 884 class Get<7> { 885 public: 886 template <class Tuple> 887 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple)) 888 Field(Tuple& t) { return t.f7_; } // NOLINT 889 890 template <class Tuple> 891 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple)) 892 ConstField(const Tuple& t) { return t.f7_; } 893 }; 894 895 template <> 896 class Get<8> { 897 public: 898 template <class Tuple> 899 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple)) 900 Field(Tuple& t) { return t.f8_; } // NOLINT 901 902 template <class Tuple> 903 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple)) 904 ConstField(const Tuple& t) { return t.f8_; } 905 }; 906 907 template <> 908 class Get<9> { 909 public: 910 template <class Tuple> 911 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple)) 912 Field(Tuple& t) { return t.f9_; } // NOLINT 913 914 template <class Tuple> 915 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple)) 916 ConstField(const Tuple& t) { return t.f9_; } 917 }; 918 919 } // namespace gtest_internal 920 921 template <int k, GTEST_10_TYPENAMES_(T)> 922 GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) 923 get(GTEST_10_TUPLE_(T)& t) { 924 return gtest_internal::Get<k>::Field(t); 925 } 926 927 template <int k, GTEST_10_TYPENAMES_(T)> 928 GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) 929 get(const GTEST_10_TUPLE_(T)& t) { 930 return gtest_internal::Get<k>::ConstField(t); 931 } 932 933 // 6.1.3.5 Relational operators 934 935 // We only implement == and !=, as we don't have a need for the rest yet. 936 937 namespace gtest_internal { 938 939 // SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the 940 // first k fields of t1 equals the first k fields of t2. 941 // SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if 942 // k1 != k2. 943 template <int kSize1, int kSize2> 944 struct SameSizeTuplePrefixComparator; 945 946 template <> 947 struct SameSizeTuplePrefixComparator<0, 0> { 948 template <class Tuple1, class Tuple2> 949 static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) { 950 return true; 951 } 952 }; 953 954 template <int k> 955 struct SameSizeTuplePrefixComparator<k, k> { 956 template <class Tuple1, class Tuple2> 957 static bool Eq(const Tuple1& t1, const Tuple2& t2) { 958 return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) && 959 ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2); 960 } 961 }; 962 963 } // namespace gtest_internal 964 965 template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)> 966 inline bool operator==(const GTEST_10_TUPLE_(T)& t, 967 const GTEST_10_TUPLE_(U)& u) { 968 return gtest_internal::SameSizeTuplePrefixComparator< 969 tuple_size<GTEST_10_TUPLE_(T) >::value, 970 tuple_size<GTEST_10_TUPLE_(U) >::value>::Eq(t, u); 971 } 972 973 template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)> 974 inline bool operator!=(const GTEST_10_TUPLE_(T)& t, 975 const GTEST_10_TUPLE_(U)& u) { return !(t == u); } 976 977 // 6.1.4 Pairs. 978 // Unimplemented. 979 980 } // namespace tr1 981 } // namespace std 982 983 #undef GTEST_0_TUPLE_ 984 #undef GTEST_1_TUPLE_ 985 #undef GTEST_2_TUPLE_ 986 #undef GTEST_3_TUPLE_ 987 #undef GTEST_4_TUPLE_ 988 #undef GTEST_5_TUPLE_ 989 #undef GTEST_6_TUPLE_ 990 #undef GTEST_7_TUPLE_ 991 #undef GTEST_8_TUPLE_ 992 #undef GTEST_9_TUPLE_ 993 #undef GTEST_10_TUPLE_ 994 995 #undef GTEST_0_TYPENAMES_ 996 #undef GTEST_1_TYPENAMES_ 997 #undef GTEST_2_TYPENAMES_ 998 #undef GTEST_3_TYPENAMES_ 999 #undef GTEST_4_TYPENAMES_ 1000 #undef GTEST_5_TYPENAMES_ 1001 #undef GTEST_6_TYPENAMES_ 1002 #undef GTEST_7_TYPENAMES_ 1003 #undef GTEST_8_TYPENAMES_ 1004 #undef GTEST_9_TYPENAMES_ 1005 #undef GTEST_10_TYPENAMES_ 1006 1007 #undef GTEST_DECLARE_TUPLE_AS_FRIEND_ 1008 #undef GTEST_BY_REF_ 1009 #undef GTEST_ADD_REF_ 1010 #undef GTEST_TUPLE_ELEMENT_ 1011 1012 #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ 1013
