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 // 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. \ 61 GTEST_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. 112 namespace std { 113 namespace tr1 { 114 115 template <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> 119 class 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. 123 namespace gtest_internal { 124 125 // ByRef<T>::type is T if T is a reference; otherwise it's const T&. 126 template <typename T> 127 struct ByRef { typedef const T& type; }; // NOLINT 128 template <typename T> 129 struct 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. 136 template <typename T> 137 struct AddRef { typedef T& type; }; // NOLINT 138 template <typename T> 139 struct 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>(). 145 template <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. 149 template <bool kIndexValid, int kIndex, class Tuple> 150 struct TupleElement; 151 152 template <GTEST_10_TYPENAMES_(T)> 153 struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > { 154 typedef T0 type; 155 }; 156 157 template <GTEST_10_TYPENAMES_(T)> 158 struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > { 159 typedef T1 type; 160 }; 161 162 template <GTEST_10_TYPENAMES_(T)> 163 struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > { 164 typedef T2 type; 165 }; 166 167 template <GTEST_10_TYPENAMES_(T)> 168 struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > { 169 typedef T3 type; 170 }; 171 172 template <GTEST_10_TYPENAMES_(T)> 173 struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > { 174 typedef T4 type; 175 }; 176 177 template <GTEST_10_TYPENAMES_(T)> 178 struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > { 179 typedef T5 type; 180 }; 181 182 template <GTEST_10_TYPENAMES_(T)> 183 struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > { 184 typedef T6 type; 185 }; 186 187 template <GTEST_10_TYPENAMES_(T)> 188 struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > { 189 typedef T7 type; 190 }; 191 192 template <GTEST_10_TYPENAMES_(T)> 193 struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > { 194 typedef T8 type; 195 }; 196 197 template <GTEST_10_TYPENAMES_(T)> 198 struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > { 199 typedef T9 type; 200 }; 201 202 } // namespace gtest_internal 203 204 template <> 205 class tuple<> { 206 public: 207 tuple() {} 208 tuple(const tuple& /* t */) {} 209 tuple& operator=(const tuple& /* t */) { return *this; } 210 }; 211 212 template <GTEST_1_TYPENAMES_(T)> 213 class 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 244 template <GTEST_2_TYPENAMES_(T)> 245 class 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 287 template <GTEST_3_TYPENAMES_(T)> 288 class 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 324 template <GTEST_4_TYPENAMES_(T)> 325 class 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 365 template <GTEST_5_TYPENAMES_(T)> 366 class 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 409 template <GTEST_6_TYPENAMES_(T)> 410 class 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 456 template <GTEST_7_TYPENAMES_(T)> 457 class 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 505 template <GTEST_8_TYPENAMES_(T)> 506 class 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 557 template <GTEST_9_TYPENAMES_(T)> 558 class 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 611 template <GTEST_10_TYPENAMES_(T)> 612 class 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 675 inline tuple<> make_tuple() { return tuple<>(); } 676 677 template <GTEST_1_TYPENAMES_(T)> 678 inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) { 679 return GTEST_1_TUPLE_(T)(f0); 680 } 681 682 template <GTEST_2_TYPENAMES_(T)> 683 inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) { 684 return GTEST_2_TUPLE_(T)(f0, f1); 685 } 686 687 template <GTEST_3_TYPENAMES_(T)> 688 inline 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 692 template <GTEST_4_TYPENAMES_(T)> 693 inline 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 698 template <GTEST_5_TYPENAMES_(T)> 699 inline 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 704 template <GTEST_6_TYPENAMES_(T)> 705 inline 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 710 template <GTEST_7_TYPENAMES_(T)> 711 inline 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 716 template <GTEST_8_TYPENAMES_(T)> 717 inline 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 722 template <GTEST_9_TYPENAMES_(T)> 723 inline 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 729 template <GTEST_10_TYPENAMES_(T)> 730 inline 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 738 template <typename Tuple> struct tuple_size; 739 740 template <GTEST_0_TYPENAMES_(T)> 741 struct tuple_size<GTEST_0_TUPLE_(T) > { 742 static const int value = 0; 743 }; 744 745 template <GTEST_1_TYPENAMES_(T)> 746 struct tuple_size<GTEST_1_TUPLE_(T) > { 747 static const int value = 1; 748 }; 749 750 template <GTEST_2_TYPENAMES_(T)> 751 struct tuple_size<GTEST_2_TUPLE_(T) > { 752 static const int value = 2; 753 }; 754 755 template <GTEST_3_TYPENAMES_(T)> 756 struct tuple_size<GTEST_3_TUPLE_(T) > { 757 static const int value = 3; 758 }; 759 760 template <GTEST_4_TYPENAMES_(T)> 761 struct tuple_size<GTEST_4_TUPLE_(T) > { 762 static const int value = 4; 763 }; 764 765 template <GTEST_5_TYPENAMES_(T)> 766 struct tuple_size<GTEST_5_TUPLE_(T) > { 767 static const int value = 5; 768 }; 769 770 template <GTEST_6_TYPENAMES_(T)> 771 struct tuple_size<GTEST_6_TUPLE_(T) > { 772 static const int value = 6; 773 }; 774 775 template <GTEST_7_TYPENAMES_(T)> 776 struct tuple_size<GTEST_7_TUPLE_(T) > { 777 static const int value = 7; 778 }; 779 780 template <GTEST_8_TYPENAMES_(T)> 781 struct tuple_size<GTEST_8_TUPLE_(T) > { 782 static const int value = 8; 783 }; 784 785 template <GTEST_9_TYPENAMES_(T)> 786 struct tuple_size<GTEST_9_TUPLE_(T) > { 787 static const int value = 9; 788 }; 789 790 template <GTEST_10_TYPENAMES_(T)> 791 struct tuple_size<GTEST_10_TUPLE_(T) > { 792 static const int value = 10; 793 }; 794 795 template <int k, class Tuple> 796 struct 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 805 namespace gtest_internal { 806 807 template <> 808 class 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 819 template <> 820 class 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 831 template <> 832 class 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 843 template <> 844 class 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 855 template <> 856 class 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 867 template <> 868 class 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 879 template <> 880 class 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 891 template <> 892 class 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 903 template <> 904 class 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 915 template <> 916 class 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 929 template <int k, GTEST_10_TYPENAMES_(T)> 930 GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) 931 get(GTEST_10_TUPLE_(T)& t) { 932 return gtest_internal::Get<k>::Field(t); 933 } 934 935 template <int k, GTEST_10_TYPENAMES_(T)> 936 GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) 937 get(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 945 namespace 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. 951 template <int kSize1, int kSize2> 952 struct SameSizeTuplePrefixComparator; 953 954 template <> 955 struct 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 962 template <int k> 963 struct 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 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) { 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 981 template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)> 982 inline 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
