include/gtest/internal/gtest-tuple.h

   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@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_