← Back to branch summary

~statik/ubuntu/lucid/protobuf/merge-bug502654

« back to all changes in this revision

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

  • Committer: Elliot Murphy
  • Date: 2010-01-18 04:26:47 UTC
  • mfrom: (2.2.2 squeeze)
  • Revision ID: elliot@elliotmurphy.com-20100118042647-c7tsnwbgifl4uso7
* Merge from Debian.
* Remaining Ubuntu changes:
  - Disable the death tests on IA64, now as a quilt patch.
  - Don't hardcode python2.4, also as a quilt patch.
* Non-maintainer upload 
* New upstream release made this evening correction major SONAME
* debian/control: Updated major version to 5            (Closes: #556563)
* debian/rules: Updated two links to use libproto*5 
* debian/libprotobuf5.shlibs: Added
* debian/libprotoc5.shlibs: Added

* Non-maintainer upload coordinated with maintainer
* New upstream release                          (Closes: #551931)
* debian/libprotobuf-install: Added 'usr/lib/pkgconfig/*' to have 
  pkg-config support files installed 
* debian/control: Added (= ${binary:Version}) to Depends for -dev 
  packages for tighter link to underlying libraries [lintian warning]
* debian/control: Updated StandardVersion: to 3.8.3

* debian/control: Major version not incremented as upstream kept it at 4

Show diffs side-by-side

added added

removed removed

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