OpenCores
URL https://opencores.org/ocsvn/s80186/s80186/trunk

Subversion Repositories s80186

[/] [s80186/] [trunk/] [vendor/] [googletest/] [googletest/] [include/] [gtest/] [internal/] [gtest-tuple.h] - Blame information for rev 2

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 jamieiles 
// 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_

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.