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