Mercurial > libbase64
comparison gtest/include/gtest/internal/gtest-tuple.h @ 0:a7fa8fee3d83
Initial import
author | David Demelier <markand@malikania.fr> |
---|---|
date | Tue, 30 Aug 2016 13:28:05 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a7fa8fee3d83 |
---|---|
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. | |
104 namespace std { | |
105 namespace tr1 { | |
106 | |
107 template <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> | |
111 class 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. | |
115 namespace gtest_internal { | |
116 | |
117 // ByRef<T>::type is T if T is a reference; otherwise it's const T&. | |
118 template <typename T> | |
119 struct ByRef { typedef const T& type; }; // NOLINT | |
120 template <typename T> | |
121 struct 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. | |
128 template <typename T> | |
129 struct AddRef { typedef T& type; }; // NOLINT | |
130 template <typename T> | |
131 struct 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>(). | |
137 template <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. | |
141 template <bool kIndexValid, int kIndex, class Tuple> | |
142 struct TupleElement; | |
143 | |
144 template <GTEST_10_TYPENAMES_(T)> | |
145 struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > { | |
146 typedef T0 type; | |
147 }; | |
148 | |
149 template <GTEST_10_TYPENAMES_(T)> | |
150 struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > { | |
151 typedef T1 type; | |
152 }; | |
153 | |
154 template <GTEST_10_TYPENAMES_(T)> | |
155 struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > { | |
156 typedef T2 type; | |
157 }; | |
158 | |
159 template <GTEST_10_TYPENAMES_(T)> | |
160 struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > { | |
161 typedef T3 type; | |
162 }; | |
163 | |
164 template <GTEST_10_TYPENAMES_(T)> | |
165 struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > { | |
166 typedef T4 type; | |
167 }; | |
168 | |
169 template <GTEST_10_TYPENAMES_(T)> | |
170 struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > { | |
171 typedef T5 type; | |
172 }; | |
173 | |
174 template <GTEST_10_TYPENAMES_(T)> | |
175 struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > { | |
176 typedef T6 type; | |
177 }; | |
178 | |
179 template <GTEST_10_TYPENAMES_(T)> | |
180 struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > { | |
181 typedef T7 type; | |
182 }; | |
183 | |
184 template <GTEST_10_TYPENAMES_(T)> | |
185 struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > { | |
186 typedef T8 type; | |
187 }; | |
188 | |
189 template <GTEST_10_TYPENAMES_(T)> | |
190 struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > { | |
191 typedef T9 type; | |
192 }; | |
193 | |
194 } // namespace gtest_internal | |
195 | |
196 template <> | |
197 class tuple<> { | |
198 public: | |
199 tuple() {} | |
200 tuple(const tuple& /* t */) {} | |
201 tuple& operator=(const tuple& /* t */) { return *this; } | |
202 }; | |
203 | |
204 template <GTEST_1_TYPENAMES_(T)> | |
205 class 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 | |
236 template <GTEST_2_TYPENAMES_(T)> | |
237 class 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 | |
279 template <GTEST_3_TYPENAMES_(T)> | |
280 class 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 | |
316 template <GTEST_4_TYPENAMES_(T)> | |
317 class 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 | |
357 template <GTEST_5_TYPENAMES_(T)> | |
358 class 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 | |
401 template <GTEST_6_TYPENAMES_(T)> | |
402 class 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 | |
448 template <GTEST_7_TYPENAMES_(T)> | |
449 class 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 | |
497 template <GTEST_8_TYPENAMES_(T)> | |
498 class 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 | |
549 template <GTEST_9_TYPENAMES_(T)> | |
550 class 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 | |
603 template <GTEST_10_TYPENAMES_(T)> | |
604 class 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 | |
667 inline tuple<> make_tuple() { return tuple<>(); } | |
668 | |
669 template <GTEST_1_TYPENAMES_(T)> | |
670 inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) { | |
671 return GTEST_1_TUPLE_(T)(f0); | |
672 } | |
673 | |
674 template <GTEST_2_TYPENAMES_(T)> | |
675 inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) { | |
676 return GTEST_2_TUPLE_(T)(f0, f1); | |
677 } | |
678 | |
679 template <GTEST_3_TYPENAMES_(T)> | |
680 inline 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 | |
684 template <GTEST_4_TYPENAMES_(T)> | |
685 inline 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 | |
690 template <GTEST_5_TYPENAMES_(T)> | |
691 inline 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 | |
696 template <GTEST_6_TYPENAMES_(T)> | |
697 inline 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 | |
702 template <GTEST_7_TYPENAMES_(T)> | |
703 inline 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 | |
708 template <GTEST_8_TYPENAMES_(T)> | |
709 inline 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 | |
714 template <GTEST_9_TYPENAMES_(T)> | |
715 inline 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 | |
721 template <GTEST_10_TYPENAMES_(T)> | |
722 inline 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 | |
730 template <typename Tuple> struct tuple_size; | |
731 | |
732 template <GTEST_0_TYPENAMES_(T)> | |
733 struct tuple_size<GTEST_0_TUPLE_(T) > { | |
734 static const int value = 0; | |
735 }; | |
736 | |
737 template <GTEST_1_TYPENAMES_(T)> | |
738 struct tuple_size<GTEST_1_TUPLE_(T) > { | |
739 static const int value = 1; | |
740 }; | |
741 | |
742 template <GTEST_2_TYPENAMES_(T)> | |
743 struct tuple_size<GTEST_2_TUPLE_(T) > { | |
744 static const int value = 2; | |
745 }; | |
746 | |
747 template <GTEST_3_TYPENAMES_(T)> | |
748 struct tuple_size<GTEST_3_TUPLE_(T) > { | |
749 static const int value = 3; | |
750 }; | |
751 | |
752 template <GTEST_4_TYPENAMES_(T)> | |
753 struct tuple_size<GTEST_4_TUPLE_(T) > { | |
754 static const int value = 4; | |
755 }; | |
756 | |
757 template <GTEST_5_TYPENAMES_(T)> | |
758 struct tuple_size<GTEST_5_TUPLE_(T) > { | |
759 static const int value = 5; | |
760 }; | |
761 | |
762 template <GTEST_6_TYPENAMES_(T)> | |
763 struct tuple_size<GTEST_6_TUPLE_(T) > { | |
764 static const int value = 6; | |
765 }; | |
766 | |
767 template <GTEST_7_TYPENAMES_(T)> | |
768 struct tuple_size<GTEST_7_TUPLE_(T) > { | |
769 static const int value = 7; | |
770 }; | |
771 | |
772 template <GTEST_8_TYPENAMES_(T)> | |
773 struct tuple_size<GTEST_8_TUPLE_(T) > { | |
774 static const int value = 8; | |
775 }; | |
776 | |
777 template <GTEST_9_TYPENAMES_(T)> | |
778 struct tuple_size<GTEST_9_TUPLE_(T) > { | |
779 static const int value = 9; | |
780 }; | |
781 | |
782 template <GTEST_10_TYPENAMES_(T)> | |
783 struct tuple_size<GTEST_10_TUPLE_(T) > { | |
784 static const int value = 10; | |
785 }; | |
786 | |
787 template <int k, class Tuple> | |
788 struct 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 | |
797 namespace gtest_internal { | |
798 | |
799 template <> | |
800 class 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 | |
811 template <> | |
812 class 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 | |
823 template <> | |
824 class 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 | |
835 template <> | |
836 class 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 | |
847 template <> | |
848 class 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 | |
859 template <> | |
860 class 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 | |
871 template <> | |
872 class 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 | |
883 template <> | |
884 class 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 | |
895 template <> | |
896 class 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 | |
907 template <> | |
908 class 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 | |
921 template <int k, GTEST_10_TYPENAMES_(T)> | |
922 GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) | |
923 get(GTEST_10_TUPLE_(T)& t) { | |
924 return gtest_internal::Get<k>::Field(t); | |
925 } | |
926 | |
927 template <int k, GTEST_10_TYPENAMES_(T)> | |
928 GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) | |
929 get(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 | |
937 namespace 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. | |
943 template <int kSize1, int kSize2> | |
944 struct SameSizeTuplePrefixComparator; | |
945 | |
946 template <> | |
947 struct 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 | |
954 template <int k> | |
955 struct 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 | |
965 template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)> | |
966 inline 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 | |
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) { 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_ |