3rdparty/googletest-1.8.1/googletest/include/gtest/internal/gtest-tuple.h

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