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