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