OSVR-Core
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 // 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_
std
Definition: TypeSafeIdHash.h:44
Eigen::Triplet
A small structure to hold a non zero as a triplet (i,j,value).
Definition: SparseUtil.h:148
Generated by   doxygen 1.8.12