0
|
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_ |