source: gtest-1.7.0/include/gtest/internal/gtest-tuple.h

Last change on this file was 12746, checked in by hock@…, 11 years ago

integrated the Google Testing Framework (gtest)

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