00001
00002 #ifndef DUNE_TUPLES_HH
00003 #define DUNE_TUPLES_HH
00004
00005 #include<ostream>
00006 #include"typetraits.hh"
00007 #include"static_assert.hh"
00008 #include"helpertemplates.hh"
00009
00010 #ifdef HAVE_TUPLE
00011 #include <tuple>
00012 #elif defined HAVE_TR1_TUPLE
00013 #include <tr1/tuple>
00014 #endif
00015
00016 namespace Dune{
00035 template<class T>
00036 struct TupleAccessTraits
00037 {
00038 typedef typename ConstantVolatileTraits<T>::ConstType& ConstType;
00039 typedef T& NonConstType;
00040 typedef const typename ConstantVolatileTraits<T>::UnqualifiedType& ParameterType;
00041 };
00042
00043 template<class T>
00044 struct TupleAccessTraits<T*>
00045 {
00046 typedef typename ConstantVolatileTraits<T>::ConstType* ConstType;
00047 typedef T* NonConstType;
00048 typedef T* ParameterType;
00049 };
00050
00051 template<class T>
00052 struct TupleAccessTraits<T&>
00053 {
00054 typedef typename ConstantVolatileTraits<T>::ConstType& ConstType;
00055 typedef T& NonConstType;
00056 typedef T& ParameterType;
00057 };
00058
00059 #ifdef HAVE_TUPLE
00060 using std::tuple;
00061 #elif defined HAVE_TR1_TUPLE
00062 using std::tr1::tuple;
00063 #else
00064
00067 struct Nil
00068 {};
00069
00070 namespace
00071 {
00072 inline const Nil nullType()
00073 {
00074 return Nil();
00075 }
00076 }
00077
00083 template<typename T1, typename TT>
00084 struct Pair
00085 {
00089 typedef T1 Type1;
00090
00094 typedef TT Type2;
00095
00096
00097
00098
00099
00100
00101
00108 template<typename T2, typename T3, typename T4, typename T5,
00109 typename T6, typename T7, typename T8, typename T9>
00110 Pair(typename TupleAccessTraits<T1>::ParameterType t1, T2& t2, T3& t3, T4& t4, T5& t5,
00111 T6& t6, T7& t7, T8& t8, T9& t9);
00112
00119 Pair(typename TupleAccessTraits<Type1>::ParameterType t1, TT& t2);
00120
00121 Pair();
00122
00127 template<typename U1, typename U2>
00128 Pair(const Pair<U1,U2>& other);
00129
00134 template<typename U1, typename U2>
00135 Pair& operator=(const Pair<U1,U2>& other);
00136
00137 Pair& operator=(const Pair& other);
00138
00143 typename TupleAccessTraits<Type1>::NonConstType first();
00144
00149 typename TupleAccessTraits<Type1>::ConstType
00150 first() const;
00151
00156 typename TupleAccessTraits<Type2>::NonConstType
00157 second();
00158
00163 typename TupleAccessTraits<Type2>::ConstType
00164 second() const;
00165
00167 Type1 first_;
00169 Type2 second_;
00170
00171 };
00172
00177 template<typename T1>
00178 struct Pair<T1,Nil>
00179 {
00183 typedef T1 Type1;
00184
00190 typedef Nil Type2;
00191
00197 Pair(typename TupleAccessTraits<T1>::ParameterType first, const Nil&, const Nil&, const Nil&, const Nil&,
00198 const Nil&, const Nil&, const Nil&, const Nil&);
00199
00205 Pair(typename TupleAccessTraits<T1>::ParameterType first,
00206 const Nil&);
00207
00208 Pair();
00209
00213 template<typename T2>
00214 Pair(const Pair<T2,Nil>& other);
00215
00219 template<typename T2>
00220 Pair& operator=(const Pair<T2,Nil>& other);
00221
00225 Pair& operator=(const Pair& other);
00226
00231 typename TupleAccessTraits<Type1>::NonConstType
00232 first();
00233
00238 typename TupleAccessTraits<Type1>::ConstType
00239 first() const;
00240
00242 Type1 first_;
00243 };
00244
00245
00249 template<typename T1, typename T2, typename T3, typename T4, typename T5,
00250 typename T6, typename T7, typename T8, typename T9>
00251 struct TupleToPairs
00252 {
00253 typedef Pair<T1, typename TupleToPairs<T2,T3,T4,T5,T6,T7,T8,T9,Nil>::Type > Type;
00254 };
00255
00259 template<typename T1>
00260 struct TupleToPairs<T1,Nil,Nil,Nil,Nil,Nil,Nil,Nil,Nil>
00261 {
00262 typedef Pair<T1,Nil> Type;
00263 };
00264
00282 template<typename T1, typename T2 = Nil, typename T3 = Nil,
00283 typename T4 = Nil, typename T5 = Nil,typename T6 = Nil,
00284 typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
00285 class tuple : public TupleToPairs<T1,T2,T3,T4,T5,T6,T7,T8,T9>::Type
00286 {
00287 public:
00289 typedef typename TupleToPairs<T1,T2,T3,T4,T5,T6,T7,T8,T9>::Type FirstPair;
00290
00291 tuple()
00292 {}
00293
00294 tuple(typename TupleAccessTraits<T1>::ParameterType t1)
00295 : FirstPair(t1, nullType(), nullType(), nullType(),
00296 nullType(), nullType(), nullType(), nullType(),
00297 nullType())
00298 {}
00299
00300 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00301 typename TupleAccessTraits<T2>::ParameterType t2)
00302 : FirstPair(t1, t2, nullType(), nullType(),
00303 nullType(), nullType(), nullType(), nullType(),
00304 nullType())
00305 {}
00306
00307 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00308 typename TupleAccessTraits<T2>::ParameterType t2,
00309 typename TupleAccessTraits<T3>::ParameterType t3)
00310 : FirstPair(t1, t2, t3, nullType(),
00311 nullType(), nullType(), nullType(), nullType(),
00312 nullType())
00313 {}
00314
00315 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00316 typename TupleAccessTraits<T2>::ParameterType t2,
00317 typename TupleAccessTraits<T3>::ParameterType t3,
00318 typename TupleAccessTraits<T4>::ParameterType t4)
00319 : FirstPair(t1, t2, t3, t4,
00320 nullType(), nullType(), nullType(), nullType(),
00321 nullType())
00322 {}
00323
00324 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00325 typename TupleAccessTraits<T2>::ParameterType t2,
00326 typename TupleAccessTraits<T3>::ParameterType t3,
00327 typename TupleAccessTraits<T4>::ParameterType t4,
00328 typename TupleAccessTraits<T5>::ParameterType t5)
00329 : FirstPair(t1, t2, t3, t4,
00330 t5, nullType(), nullType(), nullType(),
00331 nullType())
00332 {}
00333
00334 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00335 typename TupleAccessTraits<T2>::ParameterType t2,
00336 typename TupleAccessTraits<T3>::ParameterType t3,
00337 typename TupleAccessTraits<T4>::ParameterType t4,
00338 typename TupleAccessTraits<T5>::ParameterType t5,
00339 typename TupleAccessTraits<T6>::ParameterType t6)
00340 : FirstPair(t1, t2, t3, t4,
00341 t5, t6, nullType(), nullType(),
00342 nullType())
00343 {}
00344
00345 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00346 typename TupleAccessTraits<T2>::ParameterType t2,
00347 typename TupleAccessTraits<T3>::ParameterType t3,
00348 typename TupleAccessTraits<T4>::ParameterType t4,
00349 typename TupleAccessTraits<T5>::ParameterType t5,
00350 typename TupleAccessTraits<T6>::ParameterType t6,
00351 typename TupleAccessTraits<T7>::ParameterType t7)
00352 : FirstPair(t1, t2, t3, t4,
00353 t5, t6, t7, nullType(),
00354 nullType())
00355 {}
00356
00357 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00358 typename TupleAccessTraits<T2>::ParameterType t2,
00359 typename TupleAccessTraits<T3>::ParameterType t3,
00360 typename TupleAccessTraits<T4>::ParameterType t4,
00361 typename TupleAccessTraits<T5>::ParameterType t5,
00362 typename TupleAccessTraits<T6>::ParameterType t6,
00363 typename TupleAccessTraits<T7>::ParameterType t7,
00364 typename TupleAccessTraits<T8>::ParameterType t8)
00365 : FirstPair(t1, t2, t3, t4,
00366 t5, t6, t7, t8,
00367 nullType())
00368 {}
00369
00370 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00371 typename TupleAccessTraits<T2>::ParameterType t2,
00372 typename TupleAccessTraits<T3>::ParameterType t3,
00373 typename TupleAccessTraits<T4>::ParameterType t4,
00374 typename TupleAccessTraits<T5>::ParameterType t5,
00375 typename TupleAccessTraits<T6>::ParameterType t6,
00376 typename TupleAccessTraits<T7>::ParameterType t7,
00377 typename TupleAccessTraits<T8>::ParameterType t8,
00378 typename TupleAccessTraits<T9>::ParameterType t9)
00379 : FirstPair(t1, t2, t3, t4, t5, t6, t7, t8, t9)
00380 {}
00381
00382 template<class U1, class U2>
00383 tuple& operator=(const Pair<U1,U2>& other)
00384 {
00385 FirstPair::operator=(other);
00386 return *this;
00387 }
00388 };
00389
00390 #endif
00391
00392
00393 #define Tuple tuple
00394
00395 #ifdef HAVE_TUPLE
00396 using std::tuple_element;
00397 #elif defined HAVE_TR1_TUPLE
00398 using std::tr1::tuple_element;
00399 #else
00400
00403 template<int N, class Tuple>
00404 struct tuple_element
00405 {
00409 typedef typename tuple_element<N,typename Tuple::FirstPair>::type type;
00410 typedef typename tuple_element<N,typename Tuple::FirstPair>::type Type;
00411 };
00412
00413 template<int N, typename T1, typename T2>
00414 struct tuple_element<N,Pair<T1,T2> >
00415 {
00419 typedef typename tuple_element<N-1,T2>::Type type;
00420 typedef typename tuple_element<N-1,T2>::Type Type;
00421 };
00422
00426 template<typename T1, typename T2>
00427 struct tuple_element<0, Pair<T1,T2> >
00428 {
00432 typedef T1 type;
00433 typedef T1 Type;
00434 };
00435
00436 #endif
00437 #define ElementType tuple_element
00438
00439 #if defined HAVE_TUPLE || defined HAVE_TR1_TUPLE
00440 #ifdef HAVE_TUPLE
00441 #define TUPLE_NS std
00442 using std::get;
00443 #elif defined HAVE_TR1_TUPLE
00444 #define TUPLE_NS std::tr1
00445 using std::tr1::get;
00446 #endif
00447
00448
00449 template<int i>
00450 struct Element{
00451 template<typename T1>
00452 static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::NonConstType get(T1& t)
00453 {
00454 return TUPLE_NS::get<i>(t);
00455 }
00456
00457 template<typename T1>
00458 static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::ConstType get(const T1& t)
00459 {
00460 return TUPLE_NS::get<i>(t);
00461 }
00462 };
00463 #undef TUPLE_NS
00464
00465 #else
00466
00469 template<int N>
00470 struct Element
00471 {
00477 template<typename T1, typename T2>
00478 static typename TupleAccessTraits<
00479 typename tuple_element<N,Pair<T1,T2> >::type
00480 >::NonConstType
00481 get(Pair<T1,T2>& tuple)
00482 {
00483 return Element<N-1>::get(tuple.second());
00484 }
00485
00491 template<typename T1, typename T2>
00492 static typename TupleAccessTraits<
00493 typename tuple_element<N,Pair<T1,T2> >::type
00494 >::ConstType
00495 get(const Pair<T1,T2>& tuple)
00496 {
00497 return Element<N-1>::get(tuple.second());
00498 }
00499 };
00500
00504 template<>
00505 struct Element<0>
00506 {
00512 template<typename T1, typename T2>
00513 static typename TupleAccessTraits<T1>::NonConstType get(Pair<T1,T2>& tuple)
00514 {
00515 return tuple.first();
00516 }
00517
00523 template<typename T1, typename T2>
00524 static typename TupleAccessTraits<T1>::ConstType get(const Pair<T1,T2>& tuple)
00525 {
00526 return tuple.first();
00527 }
00528 };
00529
00530 template<int i, typename T1, typename T2, typename T3, typename T4,
00531 typename T5, typename T6, typename T7, typename T8, typename T9>
00532 typename TupleAccessTraits<typename tuple_element<i, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::type>
00533 ::NonConstType
00534 get(tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>& t)
00535 {
00536 return Element<i>::get(t);
00537 }
00538
00539 template<int i, typename T1, typename T2, typename T3, typename T4,
00540 typename T5, typename T6, typename T7, typename T8, typename T9>
00541 typename TupleAccessTraits<typename tuple_element<i, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::type>
00542 ::ConstType
00543 get(const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>& t)
00544 {
00545 return Element<i>::get(t);
00546 }
00547
00548 #endif
00549
00550 #ifdef HAVE_TUPLE
00551 using std::tuple_size;
00552 #elif defined HAVE_TR1_TUPLE
00553 using std::tr1::tuple_size;
00554 #else
00555
00559 template<class T>
00560 struct tuple_size
00561 {
00562 enum{
00563
00564 value=tuple_size<typename T::FirstPair>::value
00565 };
00566
00567
00568 };
00569
00570 template<typename T1, typename T2>
00571 struct tuple_size<Pair<T1,T2> >
00572 {
00573 enum{ value=1+tuple_size<T2>::value};
00574 };
00575
00576
00577 template<typename T1>
00578 struct tuple_size<Pair<T1,Nil> >
00579 {
00580 enum{ value=1};
00581 };
00582
00583 template<>
00584 struct tuple_size<Pair<Nil,Nil> >
00585 {
00586 enum{ value=0};
00587 };
00588 #endif
00589
00590 #define Size tuple_size
00591
00592 #ifdef HAVE_TUPLE
00593 using std::tie;
00594 using std::make_tuple;
00595 #elif defined HAVE_TR1_TUPLE
00596 using std::tr1::tie;
00597 using std::tr1::make_tuple;
00598 #endif
00599
00600 #if defined HAVE_TUPLE || defined HAVE_TR1_TUPLE
00601 template<int i>
00602 struct tuple_writer
00603 {
00604 template<class Tuple>
00605 static std::ostream& put(std::ostream& os, const Tuple& t)
00606 {
00607 return tuple_writer<i-1>::put(os,t)<<", "<<get<i-1>(t);
00608 }
00609 };
00610
00611 template<>
00612 struct tuple_writer<0>
00613 {
00614 template<class Tuple>
00615 static std::ostream& put(std::ostream& os, const Tuple& t)
00616 {
00617 return os;
00618 }
00619 };
00620
00624 template<typename T1>
00625 inline std::ostream& operator<<( std::ostream& os, const tuple<T1> & t)
00626 {
00627 typedef tuple<T1> Tuple;
00628 return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00629 }
00630
00631 template<typename T1, typename T2>
00632 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2> & t)
00633 {
00634 typedef tuple<T1,T2> Tuple;
00635 return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00636 }
00637
00638 template<typename T1, typename T2, typename T3>
00639 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3> & t)
00640 {
00641 typedef tuple<T1,T2,T3> Tuple;
00642 return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00643 }
00644
00645 template<typename T1, typename T2, typename T3, typename T4>
00646 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4> & t)
00647 {
00648 typedef tuple<T1,T2,T3,T4> Tuple;
00649 return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00650 }
00651
00652 template<typename T1, typename T2, typename T3, typename T4, typename T5>
00653 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5> & t)
00654 {
00655 typedef tuple<T1,T2,T3,T4,T5> Tuple;
00656 return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00657 }
00658
00659 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
00660 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6> & t)
00661 {
00662 typedef tuple<T1,T2,T3,T4,T5,T6> Tuple;
00663 return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00664 }
00665
00666 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
00667 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7> & t)
00668 {
00669 typedef tuple<T1,T2,T3,T4,T5,T6,T7> Tuple;
00670 return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00671 }
00672
00673 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
00674 typename T8>
00675 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8> & t)
00676 {
00677 typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8> Tuple;
00678 return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00679 }
00680
00681 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
00682 typename T8, typename T9>
00683 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> & t)
00684 {
00685 typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> Tuple;
00686 return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00687 }
00688
00689 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
00690 typename T8, typename T9, typename T10>
00691 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> & t)
00692 {
00693 typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Tuple;
00694 return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00695 }
00696
00697 #else
00698
00703 template<typename T1, typename T2, typename U1, typename U2>
00704 inline bool operator==(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00705 {
00706 return (tuple1.first()==tuple2.first() && tuple1.second()==tuple2.second());
00707 }
00708
00714 template<typename T1, typename T2, typename U1, typename U2>
00715 inline bool operator!=(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00716 {
00717 return (tuple1.first()!=tuple2.first() || tuple1.second()!=tuple2.second());
00718 }
00719
00725 template<typename T1, typename T2, typename U1, typename U2>
00726 inline bool operator<(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00727 {
00728 return tuple1.first() < tuple2.first()
00729 || (tuple1.first() == tuple2.first() && tuple1.second() < tuple2.second());
00730 }
00731
00737 template<typename T1,typename U1>
00738 inline bool operator==(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00739 {
00740 return (tuple1.first()==tuple2.first());
00741 }
00742
00748 template<typename T1, typename U1>
00749 inline bool operator!=(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00750 {
00751 dune_static_assert((IsInteroperable<T1,U1>::value), "T1 and U1 have to be interoperable, "<<
00752 "i.e. either conversion from one to the other must exist!");
00753 return (tuple1.first()!=tuple2.first());
00754 }
00755
00761 template<typename T1, typename U1>
00762 inline bool operator<(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00763 {
00764 return (tuple1.first()<tuple2.first());
00765 }
00766
00774 template<typename T1,typename U1, typename U2>
00775 inline bool operator==(const Pair<T1,Nil>& tuple1, const Pair<U1,U2>& tuple2)
00776 {
00777 return false;
00778 }
00779
00786 template<typename T1, typename U1, typename U2>
00787 inline bool operator!=(const Pair<T1,Nil>& tuple1, const Pair<U1,U2>& tuple2)
00788 {
00789 return true;
00790 }
00791
00792
00799 template<typename T1, typename T2, typename U1>
00800 inline bool operator==(const Pair<T1,T2>& tuple1, const Pair<U1,Nil>& tuple2)
00801 {
00802 return false;
00803 }
00804
00811 template<typename T1, typename T2, typename U1>
00812 inline bool operator!=(const Pair<T1,T2>& tuple1, const Pair<U1,Nil>& tuple2)
00813 {
00814 return true;
00815 }
00816
00822 template<typename T1, typename T2>
00823 inline Pair<T1,T2> makePair(const T1& first, const T2& second)
00824 {
00825 return Pair<T1,T2>(first, second);
00826 }
00827
00831 template<typename T1, typename T2>
00832 inline std::ostream& operator<<(std::ostream& os, const Pair<T1,T2>& pair)
00833 {
00834 os<<pair.first()<<" "<<pair.second();
00835 return os;
00836 }
00837
00838 template<typename T1>
00839 inline std::ostream& operator<<(std::ostream& os, const Pair<T1,Nil>& pair)
00840 {
00841 os<<pair.first();
00842 return os;
00843 }
00844
00845 template<class T1>
00846 inline tuple<T1&> tie(T1& t1) {
00847 return tuple<T1&> (t1);
00848 }
00849
00850 template<class T1, class T2>
00851 inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {
00852 return tuple<T1&, T2&> (t1, t2);
00853 }
00854
00855 template<class T1, class T2, class T3>
00856 inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {
00857 return tuple<T1&, T2&, T3&> (t1, t2, t3);
00858 }
00859
00860 template<class T1, class T2, class T3, class T4>
00861 inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
00862 return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);
00863 }
00864
00865 template<class T1, class T2, class T3, class T4, class T5>
00866 inline tuple<T1&, T2&, T3&, T4&, T5&>
00867 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
00868 return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
00869 }
00870
00871 template<class T1, class T2, class T3, class T4, class T5, class T6>
00872 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
00873 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
00874 return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
00875 }
00876
00877 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
00878 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
00879 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
00880 return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
00881 }
00882
00883 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00884 class T8>
00885 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
00886 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
00887 return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
00888 (t1, t2, t3, t4, t5, t6, t7, t8);
00889 }
00890
00891 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00892 class T8, class T9>
00893 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
00894 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9) {
00895 return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
00896 (t1, t2, t3, t4, t5, t6, t7, t8, t9);
00897 }
00898
00899 template<class T1>
00900 inline tuple<T1> make_tuple(const T1& t1) {
00901 return tuple<T1> (t1);
00902 }
00903
00904 template<class T1, class T2>
00905 inline tuple<T1, T2> make_tuple(const T1& t1, const T2& t2) {
00906 return tuple<T1, T2> (t1, t2);
00907 }
00908
00909 template<class T1, class T2, class T3>
00910 inline tuple<T1, T2, T3> make_tuple(const T1& t1, const T2& t2, const T3& t3) {
00911 return tuple<T1, T2, T3> (t1, t2, t3);
00912 }
00913
00914 template<class T1, class T2, class T3, class T4>
00915 inline tuple<T1, T2, T3, T4> make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
00916 return tuple<T1, T2, T3, T4> (t1, t2, t3, t4);
00917 }
00918
00919 template<class T1, class T2, class T3, class T4, class T5>
00920 inline tuple<T1, T2, T3, T4, T5>
00921 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) {
00922 return tuple<T1, T2, T3, T4, T5> (t1, t2, t3, t4, t5);
00923 }
00924
00925 template<class T1, class T2, class T3, class T4, class T5, class T6>
00926 inline tuple<T1, T2, T3, T4, T5, T6>
00927 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) {
00928 return tuple<T1, T2, T3, T4, T5, T6> (t1, t2, t3, t4, t5, t6);
00929 }
00930
00931 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
00932 inline tuple<T1, T2, T3, T4, T5, T6, T7>
00933 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00934 const T7& t7) {
00935 return tuple<T1, T2, T3, T4, T5, T6, T7> (t1, t2, t3, t4, t5, t6, t7);
00936 }
00937
00938 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00939 class T8>
00940 inline tuple<T1, T2, T3, T4, T5, T6, T7, T8>
00941 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00942 const T7& t7, const T8& t8) {
00943 return tuple<T1, T2, T3, T4, T5, T6, T7, T8>
00944 (t1, t2, t3, t4, t5, t6, t7, t8);
00945 }
00946
00947 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00948 class T8, class T9>
00949 inline tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
00950 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00951 const T7& t7, const T8& t8, const T9& t9) {
00952 return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
00953 (t1, t2, t3, t4, t5, t6, t7, t8, t9);
00954 }
00955
00956 template<typename T1, typename TT>
00957 template<typename T2, typename T3, typename T4, typename T5,
00958 typename T6, typename T7, typename T8, typename T9>
00959 inline Pair<T1,TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
00960 T2& t2, T3& t3, T4& t4, T5& t5,
00961 T6& t6, T7& t7, T8& t8, T9& t9)
00962 : first_(first), second_(t2,t3,t4,t5,t6,t7,t8,t9, nullType())
00963 {}
00964
00965 template <typename T1, typename TT>
00966 inline Pair<T1, TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first, TT& second)
00967 : first_(first), second_(second)
00968 {}
00969
00970 template<typename T1, typename T2>
00971 inline Pair<T1,T2>::Pair()
00972 : first_(), second_()
00973 {}
00974
00975 template<typename T1, typename T2>
00976 template<typename U1, typename U2>
00977 inline Pair<T1,T2>::Pair(const Pair<U1,U2>& other)
00978 : first_(other.first_), second_(other.second_)
00979 {}
00980
00981 template<typename T1, typename T2>
00982 template<typename U1, typename U2>
00983 inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair<U1,U2>& other)
00984 {
00985 first_=other.first_;
00986 second_=other.second_;
00987 return *this;
00988 }
00989
00990 template<typename T1, typename T2>
00991 inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair& other)
00992 {
00993 first_=other.first_;
00994 second_=other.second_;
00995 return *this;
00996 }
00997
00998 template<typename T1, typename T2>
00999 inline typename TupleAccessTraits<T1>::NonConstType
01000 Pair<T1,T2>::first()
01001 {
01002 return first_;
01003 }
01004
01005 template<typename T1, typename T2>
01006 inline typename TupleAccessTraits<T1>::ConstType
01007 Pair<T1,T2>::first() const
01008 {
01009 return first_;
01010 }
01011
01012
01013 template<typename T1, typename T2>
01014 inline typename TupleAccessTraits<T2>::NonConstType
01015 Pair<T1,T2>::second()
01016 {
01017 return second_;
01018 }
01019
01020 template<typename T1, typename T2>
01021 inline typename TupleAccessTraits<T2>::ConstType
01022 Pair<T1,T2>::second() const
01023 {
01024 return second_;
01025 }
01026
01027 template<typename T1>
01028 inline Pair<T1,Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
01029 const Nil&, const Nil&, const Nil&, const Nil&,
01030 const Nil&, const Nil&, const Nil&, const Nil&)
01031 : first_(first)
01032 {}
01033
01034 template <typename T1>
01035 inline Pair<T1, Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
01036 const Nil&)
01037 : first_(first)
01038 {}
01039
01040 template<typename T1>
01041 inline Pair<T1,Nil>::Pair()
01042 : first_()
01043 {}
01044
01045 template<typename T1>
01046 template<typename T2>
01047 inline Pair<T1,Nil>::Pair(const Pair<T2,Nil>& other)
01048 : first_(other.first_)
01049 {}
01050
01051 template<typename T1>
01052 template<typename T2>
01053 Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair<T2,Nil>& other)
01054 {
01055 first_ = other.first_;
01056 return *this;
01057 }
01058
01059
01060 template<typename T1>
01061 Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair& other)
01062 {
01063 first_ = other.first_;
01064 return *this;
01065 }
01066
01067 template<typename T1>
01068 inline typename TupleAccessTraits<T1>::NonConstType
01069 Pair<T1,Nil>::first()
01070 {
01071 return first_;
01072 }
01073
01074 template<typename T1>
01075 inline typename TupleAccessTraits<T1>::ConstType
01076 Pair<T1,Nil>::first() const
01077 {
01078 return first_;
01079 }
01080
01081 #endif
01082 }
01083 #endif