← Back to branch summary

~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

« back to all changes in this revision

Viewing changes to Source/ThirdParty/gtest/include/gtest/internal/gtest-tuple.h

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-02-18 14:24:18 UTC
  • Revision ID: package-import@ubuntu.com-20130218142418-eon0jmjg3nj438uy
Tags: upstream-2.3
Import upstream version 2.3

Show diffs side-by-side

added added

removed removed

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