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