inference-engine/tests/libs/gtest/googletest/include/gtest/internal/gtest-tuple.h

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