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