Faiss

- Main Page
- Namespaces
- Classes
- Files

- File List

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