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