gtest-tuple.h revision 2079:65f446a2bdd7
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@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. 104namespace std { 105namespace tr1 { 106 107template <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> 111class 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. 115namespace gtest_internal { 116 117// ByRef<T>::type is T if T is a reference; otherwise it's const T&. 118template <typename T> 119struct ByRef { typedef const T& type; }; // NOLINT 120template <typename T> 121struct 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. 128template <typename T> 129struct AddRef { typedef T& type; }; // NOLINT 130template <typename T> 131struct 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>(). 137template <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. 141template <bool kIndexValid, int kIndex, class Tuple> 142struct TupleElement; 143 144template <GTEST_10_TYPENAMES_(T)> 145struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > { 146 typedef T0 type; 147}; 148 149template <GTEST_10_TYPENAMES_(T)> 150struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > { 151 typedef T1 type; 152}; 153 154template <GTEST_10_TYPENAMES_(T)> 155struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > { 156 typedef T2 type; 157}; 158 159template <GTEST_10_TYPENAMES_(T)> 160struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > { 161 typedef T3 type; 162}; 163 164template <GTEST_10_TYPENAMES_(T)> 165struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > { 166 typedef T4 type; 167}; 168 169template <GTEST_10_TYPENAMES_(T)> 170struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > { 171 typedef T5 type; 172}; 173 174template <GTEST_10_TYPENAMES_(T)> 175struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > { 176 typedef T6 type; 177}; 178 179template <GTEST_10_TYPENAMES_(T)> 180struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > { 181 typedef T7 type; 182}; 183 184template <GTEST_10_TYPENAMES_(T)> 185struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > { 186 typedef T8 type; 187}; 188 189template <GTEST_10_TYPENAMES_(T)> 190struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > { 191 typedef T9 type; 192}; 193 194} // namespace gtest_internal 195 196template <> 197class tuple<> { 198 public: 199 tuple() {} 200 tuple(const tuple& /* t */) {} 201 tuple& operator=(const tuple& /* t */) { return *this; } 202}; 203 204template <GTEST_1_TYPENAMES_(T)> 205class 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 236template <GTEST_2_TYPENAMES_(T)> 237class 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 279template <GTEST_3_TYPENAMES_(T)> 280class 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 316template <GTEST_4_TYPENAMES_(T)> 317class 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 357template <GTEST_5_TYPENAMES_(T)> 358class 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 401template <GTEST_6_TYPENAMES_(T)> 402class 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 448template <GTEST_7_TYPENAMES_(T)> 449class 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 497template <GTEST_8_TYPENAMES_(T)> 498class 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 549template <GTEST_9_TYPENAMES_(T)> 550class 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 603template <GTEST_10_TYPENAMES_(T)> 604class 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 667inline tuple<> make_tuple() { return tuple<>(); } 668 669template <GTEST_1_TYPENAMES_(T)> 670inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) { 671 return GTEST_1_TUPLE_(T)(f0); 672} 673 674template <GTEST_2_TYPENAMES_(T)> 675inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) { 676 return GTEST_2_TUPLE_(T)(f0, f1); 677} 678 679template <GTEST_3_TYPENAMES_(T)> 680inline 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 684template <GTEST_4_TYPENAMES_(T)> 685inline 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 690template <GTEST_5_TYPENAMES_(T)> 691inline 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 696template <GTEST_6_TYPENAMES_(T)> 697inline 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 702template <GTEST_7_TYPENAMES_(T)> 703inline 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 708template <GTEST_8_TYPENAMES_(T)> 709inline 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 714template <GTEST_9_TYPENAMES_(T)> 715inline 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 721template <GTEST_10_TYPENAMES_(T)> 722inline 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 730template <typename Tuple> struct tuple_size; 731 732template <GTEST_0_TYPENAMES_(T)> 733struct tuple_size<GTEST_0_TUPLE_(T) > { 734 static const int value = 0; 735}; 736 737template <GTEST_1_TYPENAMES_(T)> 738struct tuple_size<GTEST_1_TUPLE_(T) > { 739 static const int value = 1; 740}; 741 742template <GTEST_2_TYPENAMES_(T)> 743struct tuple_size<GTEST_2_TUPLE_(T) > { 744 static const int value = 2; 745}; 746 747template <GTEST_3_TYPENAMES_(T)> 748struct tuple_size<GTEST_3_TUPLE_(T) > { 749 static const int value = 3; 750}; 751 752template <GTEST_4_TYPENAMES_(T)> 753struct tuple_size<GTEST_4_TUPLE_(T) > { 754 static const int value = 4; 755}; 756 757template <GTEST_5_TYPENAMES_(T)> 758struct tuple_size<GTEST_5_TUPLE_(T) > { 759 static const int value = 5; 760}; 761 762template <GTEST_6_TYPENAMES_(T)> 763struct tuple_size<GTEST_6_TUPLE_(T) > { 764 static const int value = 6; 765}; 766 767template <GTEST_7_TYPENAMES_(T)> 768struct tuple_size<GTEST_7_TUPLE_(T) > { 769 static const int value = 7; 770}; 771 772template <GTEST_8_TYPENAMES_(T)> 773struct tuple_size<GTEST_8_TUPLE_(T) > { 774 static const int value = 8; 775}; 776 777template <GTEST_9_TYPENAMES_(T)> 778struct tuple_size<GTEST_9_TUPLE_(T) > { 779 static const int value = 9; 780}; 781 782template <GTEST_10_TYPENAMES_(T)> 783struct tuple_size<GTEST_10_TUPLE_(T) > { 784 static const int value = 10; 785}; 786 787template <int k, class Tuple> 788struct 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 797namespace gtest_internal { 798 799template <> 800class 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 811template <> 812class 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 823template <> 824class 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 835template <> 836class 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 847template <> 848class 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 859template <> 860class 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 871template <> 872class 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 883template <> 884class 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 895template <> 896class 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 907template <> 908class 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 921template <int k, GTEST_10_TYPENAMES_(T)> 922GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) 923get(GTEST_10_TUPLE_(T)& t) { 924 return gtest_internal::Get<k>::Field(t); 925} 926 927template <int k, GTEST_10_TYPENAMES_(T)> 928GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) 929get(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 937namespace 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. 943template <int kSize1, int kSize2> 944struct SameSizeTuplePrefixComparator; 945 946template <> 947struct 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 954template <int k> 955struct 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 965template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)> 966inline 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 973template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)> 974inline 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