Wire Sysio Wire Sysion 1.0.0
Loading...
Searching...
No Matches
Namespaces | Classes | Functions | Variables
std::tr1 Namespace Reference

Namespaces

namespace  gtest_internal
 

Classes

class  tuple
 
class  tuple<>
 
struct  tuple_element
 
struct  tuple_size
 
struct  tuple_size< GTEST_0_TUPLE_(T) >
 
struct  tuple_size< GTEST_10_TUPLE_(T) >
 
struct  tuple_size< GTEST_1_TUPLE_(T) >
 
struct  tuple_size< GTEST_2_TUPLE_(T) >
 
struct  tuple_size< GTEST_3_TUPLE_(T) >
 
struct  tuple_size< GTEST_4_TUPLE_(T) >
 
struct  tuple_size< GTEST_5_TUPLE_(T) >
 
struct  tuple_size< GTEST_6_TUPLE_(T) >
 
struct  tuple_size< GTEST_7_TUPLE_(T) >
 
struct  tuple_size< GTEST_8_TUPLE_(T) >
 
struct  tuple_size< GTEST_9_TUPLE_(T) >
 

Functions

template<GTEST_1_TYPENAMES_(T) >
class GTEST_1_TUPLE_ (T)
 
template<GTEST_2_TYPENAMES_(T) >
class GTEST_2_TUPLE_ (T)
 
template<GTEST_3_TYPENAMES_(T) >
class GTEST_3_TUPLE_ (T)
 
template<GTEST_4_TYPENAMES_(T) >
class GTEST_4_TUPLE_ (T)
 
template<GTEST_5_TYPENAMES_(T) >
class GTEST_5_TUPLE_ (T)
 
template<GTEST_6_TYPENAMES_(T) >
class GTEST_6_TUPLE_ (T)
 
template<GTEST_7_TYPENAMES_(T) >
class GTEST_7_TUPLE_ (T)
 
template<GTEST_8_TYPENAMES_(T) >
class GTEST_8_TUPLE_ (T)
 
template<GTEST_9_TYPENAMES_(T) >
class GTEST_9_TUPLE_ (T)
 
tuple make_tuple ()
 
template<GTEST_1_TYPENAMES_(T) >
 GTEST_1_TUPLE_ (T) make_tuple(const T0 &f0)
 
template<GTEST_2_TYPENAMES_(T) >
 GTEST_2_TUPLE_ (T) make_tuple(const T0 &f0
 
template<GTEST_3_TYPENAMES_(T) >
 GTEST_3_TUPLE_ (T) make_tuple(const T0 &f0
 
template<GTEST_4_TYPENAMES_(T) >
 GTEST_4_TUPLE_ (T) make_tuple(const T0 &f0
 
template<GTEST_5_TYPENAMES_(T) >
 GTEST_5_TUPLE_ (T) make_tuple(const T0 &f0
 
template<GTEST_6_TYPENAMES_(T) >
 GTEST_6_TUPLE_ (T) make_tuple(const T0 &f0
 
template<GTEST_7_TYPENAMES_(T) >
 GTEST_7_TUPLE_ (T) make_tuple(const T0 &f0
 
template<GTEST_8_TYPENAMES_(T) >
 GTEST_8_TUPLE_ (T) make_tuple(const T0 &f0
 
template<GTEST_9_TYPENAMES_(T) >
 GTEST_9_TUPLE_ (T) make_tuple(const T0 &f0
 
template<GTEST_10_TYPENAMES_(T) >
 GTEST_10_TUPLE_ (T) make_tuple(const T0 &f0
 
template<int k, GTEST_10_TYPENAMES_(T) >
 GTEST_ADD_REF_ (GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) get(GTEST_10_TUPLE_(T) &t)
 
template<int k, GTEST_10_TYPENAMES_(T) >
 GTEST_BY_REF_ (GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) get(const GTEST_10_TUPLE_(T) &t)
 
template<GTEST_10_TYPENAMES_(T) , GTEST_10_TYPENAMES_(U) >
bool operator== (const GTEST_10_TUPLE_(T)&t, const GTEST_10_TUPLE_(U)&u)
 
template<GTEST_10_TYPENAMES_(T) , GTEST_10_TYPENAMES_(U) >
bool operator!= (const GTEST_10_TUPLE_(T)&t, const GTEST_10_TUPLE_(U)&u)
 

Variables

const T1 & f1
 
const T1 const T2 & f2
 
const T1 const T2 const T3 & f3
 
const T1 const T2 const T3 const T4 & f4
 
const T1 const T2 const T3 const T4 const T5 & f5
 
const T1 const T2 const T3 const T4 const T5 const T6 & f6
 
const T1 const T2 const T3 const T4 const T5 const T6 const T7 & f7
 
const T1 const T2 const T3 const T4 const T5 const T6 const T7 const T8 & f8
 
const T1 const T2 const T3 const T4 const T5 const T6 const T7 const T8 const T9 & f9
 

Function Documentation

◆ GTEST_10_TUPLE_()

template<GTEST_10_TYPENAMES_(T) >
std::tr1::GTEST_10_TUPLE_ ( T ) const &
inline

◆ GTEST_1_TUPLE_() [1/2]

template<GTEST_1_TYPENAMES_(T) >
class std::tr1::GTEST_1_TUPLE_ ( T )

Definition at line 1 of file gtest-tuple.h.

213 {
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};
std::tr1::gtest_internal::Get
Definition gtest-tuple.h:145
GTEST_DECLARE_TUPLE_AS_FRIEND_
#define GTEST_DECLARE_TUPLE_AS_FRIEND_
Definition gtest-tuple.h:51
GTEST_1_TUPLE_
#define GTEST_1_TUPLE_(T)
Definition gtest-tuple.h:66
GTEST_BY_REF_
#define GTEST_BY_REF_(T)
Definition gtest-tuple.h:132
U
Definition dtoa.c:306

◆ GTEST_1_TUPLE_() [2/2]

template<GTEST_1_TYPENAMES_(T) >
std::tr1::GTEST_1_TUPLE_ ( T ) const &
inline

Definition at line 678 of file gtest-tuple.h.

678 {
679 return GTEST_1_TUPLE_(T)(f0);
680}
T
#define T(meth, val, expected)

◆ GTEST_2_TUPLE_() [1/2]

template<GTEST_2_TYPENAMES_(T) >
class std::tr1::GTEST_2_TUPLE_ ( T )

Definition at line 1 of file gtest-tuple.h.

245 {
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};
p
const mie::Vuint & p
Definition bn.cpp:27
GTEST_2_TUPLE_
#define GTEST_2_TUPLE_(T)
Definition gtest-tuple.h:68

◆ GTEST_2_TUPLE_() [2/2]

template<GTEST_2_TYPENAMES_(T) >
std::tr1::GTEST_2_TUPLE_ ( T ) const &
inline

◆ GTEST_3_TUPLE_() [1/2]

template<GTEST_3_TYPENAMES_(T) >
class std::tr1::GTEST_3_TUPLE_ ( T )

Definition at line 1 of file gtest-tuple.h.

288 {
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};
GTEST_3_TUPLE_
#define GTEST_3_TUPLE_(T)
Definition gtest-tuple.h:70

◆ GTEST_3_TUPLE_() [2/2]

template<GTEST_3_TYPENAMES_(T) >
std::tr1::GTEST_3_TUPLE_ ( T ) const &
inline

◆ GTEST_4_TUPLE_() [1/2]

template<GTEST_4_TYPENAMES_(T) >
class std::tr1::GTEST_4_TUPLE_ ( T )

Definition at line 1 of file gtest-tuple.h.

325 {
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};
GTEST_4_TUPLE_
#define GTEST_4_TUPLE_(T)
Definition gtest-tuple.h:72

◆ GTEST_4_TUPLE_() [2/2]

template<GTEST_4_TYPENAMES_(T) >
std::tr1::GTEST_4_TUPLE_ ( T ) const &
inline

◆ GTEST_5_TUPLE_() [1/2]

template<GTEST_5_TYPENAMES_(T) >
class std::tr1::GTEST_5_TUPLE_ ( T )

Definition at line 1 of file gtest-tuple.h.

366 {
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};
GTEST_5_TUPLE_
#define GTEST_5_TUPLE_(T)
Definition gtest-tuple.h:74

◆ GTEST_5_TUPLE_() [2/2]

template<GTEST_5_TYPENAMES_(T) >
std::tr1::GTEST_5_TUPLE_ ( T ) const &
inline

◆ GTEST_6_TUPLE_() [1/2]

template<GTEST_6_TYPENAMES_(T) >
class std::tr1::GTEST_6_TUPLE_ ( T )

Definition at line 1 of file gtest-tuple.h.

410 {
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};
GTEST_6_TUPLE_
#define GTEST_6_TUPLE_(T)
Definition gtest-tuple.h:76

◆ GTEST_6_TUPLE_() [2/2]

template<GTEST_6_TYPENAMES_(T) >
std::tr1::GTEST_6_TUPLE_ ( T ) const &
inline

◆ GTEST_7_TUPLE_() [1/2]

template<GTEST_7_TYPENAMES_(T) >
class std::tr1::GTEST_7_TUPLE_ ( T )

Definition at line 1 of file gtest-tuple.h.

457 {
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};
GTEST_7_TUPLE_
#define GTEST_7_TUPLE_(T)
Definition gtest-tuple.h:78

◆ GTEST_7_TUPLE_() [2/2]

template<GTEST_7_TYPENAMES_(T) >
std::tr1::GTEST_7_TUPLE_ ( T ) const &
inline

◆ GTEST_8_TUPLE_() [1/2]

template<GTEST_8_TYPENAMES_(T) >
class std::tr1::GTEST_8_TUPLE_ ( T )

Definition at line 1 of file gtest-tuple.h.

506 {
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};
GTEST_8_TUPLE_
#define GTEST_8_TUPLE_(T)
Definition gtest-tuple.h:80

◆ GTEST_8_TUPLE_() [2/2]

template<GTEST_8_TYPENAMES_(T) >
std::tr1::GTEST_8_TUPLE_ ( T ) const &
inline

◆ GTEST_9_TUPLE_() [1/2]

template<GTEST_9_TYPENAMES_(T) >
class std::tr1::GTEST_9_TUPLE_ ( T )

Definition at line 1 of file gtest-tuple.h.

558 {
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};
GTEST_9_TUPLE_
#define GTEST_9_TUPLE_(T)
Definition gtest-tuple.h:82

◆ GTEST_9_TUPLE_() [2/2]

template<GTEST_9_TYPENAMES_(T) >
std::tr1::GTEST_9_TUPLE_ ( T ) const &
inline

◆ GTEST_ADD_REF_()

template<int k, GTEST_10_TYPENAMES_(T) >
std::tr1::GTEST_ADD_REF_ ( GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)) ) &

Definition at line 930 of file gtest-tuple.h.

931 {
932 return gtest_internal::Get<k>::Field(t);
933}

◆ GTEST_BY_REF_()

template<int k, GTEST_10_TYPENAMES_(T) >
std::tr1::GTEST_BY_REF_ ( GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)) ) const &

Definition at line 936 of file gtest-tuple.h.

937 {
938 return gtest_internal::Get<k>::ConstField(t);
939}

◆ make_tuple()

tuple std::tr1::make_tuple ( )
inline

Definition at line 675 of file gtest-tuple.h.

675{ return tuple<>(); }

◆ operator!=()

template<GTEST_10_TYPENAMES_(T) , GTEST_10_TYPENAMES_(U) >
bool std::tr1::operator!= ( const GTEST_10_TUPLE_(T)& t,
const GTEST_10_TUPLE_(U)& u )
inline

Definition at line 982 of file gtest-tuple.h.

983 { return !(t == u); }

◆ operator==()

template<GTEST_10_TYPENAMES_(T) , GTEST_10_TYPENAMES_(U) >
bool std::tr1::operator== ( const GTEST_10_TUPLE_(T)& t,
const GTEST_10_TUPLE_(U)& u )
inline

Definition at line 974 of file gtest-tuple.h.

975 {
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}
GTEST_10_TUPLE_
#define GTEST_10_TUPLE_(T)
Definition gtest-tuple.h:84
value
#define value
Definition pkcs11.h:157
std::tr1::gtest_internal::SameSizeTuplePrefixComparator
Definition gtest-tuple.h:952
std::tr1::tuple_size
Definition gtest-tuple.h:738

Variable Documentation

◆ f1

const T1 & std::tr1::f1
Initial value:
{
return GTEST_2_TUPLE_(T)(f0, f1)
std::tr1::f1
const T1 & f1
Definition gtest-tuple.h:683

Definition at line 683 of file gtest-tuple.h.

◆ f2

const T1 const T2 & std::tr1::f2
Initial value:
{
return GTEST_3_TUPLE_(T)(f0, f1, f2)
std::tr1::f2
const T1 const T2 & f2
Definition gtest-tuple.h:688

Definition at line 688 of file gtest-tuple.h.

◆ f3

const T1 const T2 const T3 & std::tr1::f3
Initial value:
{
return GTEST_4_TUPLE_(T)(f0, f1, f2, f3)
std::tr1::f3
const T1 const T2 const T3 & f3
Definition gtest-tuple.h:694

Definition at line 694 of file gtest-tuple.h.

◆ f4

const T1 const T2 const T3 const T4 & std::tr1::f4
Initial value:
{
return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4)
std::tr1::f4
const T1 const T2 const T3 const T4 & f4
Definition gtest-tuple.h:700

Definition at line 700 of file gtest-tuple.h.

◆ f5

const T1 const T2 const T3 const T4 const T5 & std::tr1::f5
Initial value:
{
return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5)
std::tr1::f5
const T1 const T2 const T3 const T4 const T5 & f5
Definition gtest-tuple.h:706

Definition at line 706 of file gtest-tuple.h.

◆ f6

const T1 const T2 const T3 const T4 const T5 const T6 & std::tr1::f6
Initial value:
{
return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6)
std::tr1::f6
const T1 const T2 const T3 const T4 const T5 const T6 & f6
Definition gtest-tuple.h:712

Definition at line 712 of file gtest-tuple.h.

◆ f7

const T1 const T2 const T3 const T4 const T5 const T6 const T7 & std::tr1::f7
Initial value:
{
return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7)
std::tr1::f7
const T1 const T2 const T3 const T4 const T5 const T6 const T7 & f7
Definition gtest-tuple.h:718

Definition at line 718 of file gtest-tuple.h.

◆ f8

const T1 const T2 const T3 const T4 const T5 const T6 const T7 const T8 & std::tr1::f8
Initial value:
{
return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8)
std::tr1::f8
const T1 const T2 const T3 const T4 const T5 const T6 const T7 const T8 & f8
Definition gtest-tuple.h:725

Definition at line 725 of file gtest-tuple.h.

◆ f9

const T1 const T2 const T3 const T4 const T5 const T6 const T7 const T8 const T9& std::tr1::f9
Initial value:
{
return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9)
std::tr1::f9
const T1 const T2 const T3 const T4 const T5 const T6 const T7 const T8 const T9 & f9
Definition gtest-tuple.h:732

Definition at line 732 of file gtest-tuple.h.