00001
00002 #ifndef DUNE_TUPLES_HH
00003 #define DUNE_TUPLES_HH
00004
00005 #include<ostream>
00006 #include"typetraits.hh"
00007 #include"helpertemplates.hh"
00008
00009 #ifdef HAVE_TUPLE
00010 #include <tuple>
00011 #endif
00012 #ifdef 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 #ifdef HAVE_TR1_TUPLE
00440 using std::tr1::get;
00441
00442
00443 template<int i>
00444 struct Element{
00445 template<typename T1>
00446 static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::NonConstType get(T1& t)
00447 {
00448 return std::tr1::get<i>(t);
00449 }
00450
00451 template<typename T1>
00452 static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::ConstType get(const T1& t)
00453 {
00454 return std::tr1::get<i>(t);
00455 }
00456 };
00457 #elif defined HAVE_TUPLE
00458 using std::get;
00459
00460
00461 template<int i>
00462 struct Element{
00463 template<typename T1>
00464 static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::NonConstType get(T1& t)
00465 {
00466 return std::get<i>(t);
00467 }
00468
00469 template<typename T1>
00470 static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::ConstType get(const T1& t)
00471 {
00472 return std::get<i>(t);
00473 }
00474 };
00475 #else
00476
00479 template<int N>
00480 struct Element
00481 {
00487 template<typename T1, typename T2>
00488 static typename TupleAccessTraits<
00489 typename tuple_element<N,Pair<T1,T2> >::type
00490 >::NonConstType
00491 get(Pair<T1,T2>& tuple)
00492 {
00493 return Element<N-1>::get(tuple.second());
00494 }
00495
00501 template<typename T1, typename T2>
00502 static typename TupleAccessTraits<
00503 typename tuple_element<N,Pair<T1,T2> >::type
00504 >::ConstType
00505 get(const Pair<T1,T2>& tuple)
00506 {
00507 return Element<N-1>::get(tuple.second());
00508 }
00509 };
00510
00514 template<>
00515 struct Element<0>
00516 {
00522 template<typename T1, typename T2>
00523 static typename TupleAccessTraits<T1>::NonConstType get(Pair<T1,T2>& tuple)
00524 {
00525 return tuple.first();
00526 }
00527
00533 template<typename T1, typename T2>
00534 static typename TupleAccessTraits<T1>::ConstType get(const Pair<T1,T2>& tuple)
00535 {
00536 return tuple.first();
00537 }
00538 };
00539
00540 template<int i, typename T1, typename T2, typename T3, typename T4,
00541 typename T5, typename T6, typename T7, typename T8, typename T9>
00542 typename TupleAccessTraits<typename tuple_element<i, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::type>
00543 ::NonConstType
00544 get(tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>& t)
00545 {
00546 return Element<i>::get(t);
00547 }
00548
00549 #endif
00550
00551 #ifdef HAVE_TR1_TUPLE
00552 using std::tr1::tuple_size;
00553 #elif defined HAVE_TUPLE
00554 using std::tuple_size;
00555 #else
00556
00560 template<class T>
00561 struct tuple_size
00562 {
00563 enum{
00564
00565 value=tuple_size<typename T::FirstPair>::value
00566 };
00567
00568
00569 };
00570
00571 template<typename T1, typename T2>
00572 struct tuple_size<Pair<T1,T2> >
00573 {
00574 enum{ value=1+tuple_size<T2>::value};
00575 };
00576
00577
00578 template<typename T1>
00579 struct tuple_size<Pair<T1,Nil> >
00580 {
00581 enum{ value=1};
00582 };
00583
00584 template<>
00585 struct tuple_size<Pair<Nil,Nil> >
00586 {
00587 enum{ value=0};
00588 };
00589 #endif
00590
00591 #define Size tuple_size
00592
00593 #ifdef HAVE_TR1_TUPLE
00594 using std::tr1::tie;
00595 using std::tr1::make_tuple;
00596 #endif
00597 #ifdef HAVE_TUPLE
00598 using std::tie;
00599 using std::make_tuple;
00600 #endif
00601
00602 #if defined HAVE_TUPLE || defined HAVE_TR1_TUPLE
00603 template<int i>
00604 struct tuple_writer
00605 {
00606 template<class Tuple>
00607 static std::ostream& put(std::ostream& os, const Tuple& t)
00608 {
00609 return tuple_writer<i-1>::put(os,t)<<", "<<get<i-1>(t);
00610 }
00611 };
00612
00613 template<>
00614 struct tuple_writer<0>
00615 {
00616 template<class Tuple>
00617 static std::ostream& put(std::ostream& os, const Tuple& t)
00618 {
00619 return os;
00620 }
00621 };
00622
00626 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
00627 typename T8, typename T9>
00628 inline std::ostream& operator<<( std::ostream& os, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> t)
00629 {
00630 typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> Tuple;
00631 return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00632 }
00633
00634
00635 #else
00636
00641 template<typename T1, typename T2, typename U1, typename U2>
00642 inline bool operator==(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00643 {
00644 return (tuple1.first()==tuple2.first() && tuple1.second()==tuple2.second());
00645 }
00646
00652 template<typename T1, typename T2, typename U1, typename U2>
00653 inline bool operator!=(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00654 {
00655 return (tuple1.first()!=tuple2.first() || tuple1.second()!=tuple2.second());
00656 }
00657
00663 template<typename T1, typename T2, typename U1, typename U2>
00664 inline bool operator<(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00665 {
00666 return tuple1.first() < tuple2.first()
00667 || (tuple1.first() == tuple2.first() && tuple1.second() < tuple2.second());
00668 }
00669
00675 template<typename T1,typename U1>
00676 inline bool operator==(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00677 {
00678 return (tuple1.first()==tuple2.first());
00679 }
00680
00686 template<typename T1, typename U1>
00687 inline bool operator!=(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00688 {
00689 IsTrue<IsInteroperable<T1,U1>::value>::yes();
00690 return (tuple1.first()!=tuple2.first());
00691 }
00692
00698 template<typename T1, typename U1>
00699 inline bool operator<(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00700 {
00701 return (tuple1.first()<tuple2.first());
00702 }
00703
00711 template<typename T1,typename U1, typename U2>
00712 inline bool operator==(const Pair<T1,Nil>& tuple1, const Pair<U1,U2>& tuple2)
00713 {
00714 return false;
00715 }
00716
00723 template<typename T1, typename U1, typename U2>
00724 inline bool operator!=(const Pair<T1,Nil>& tuple1, const Pair<U1,U2>& tuple2)
00725 {
00726 return true;
00727 }
00728
00729
00736 template<typename T1, typename T2, typename U1>
00737 inline bool operator==(const Pair<T1,T2>& tuple1, const Pair<U1,Nil>& tuple2)
00738 {
00739 return false;
00740 }
00741
00748 template<typename T1, typename T2, typename U1>
00749 inline bool operator!=(const Pair<T1,T2>& tuple1, const Pair<U1,Nil>& tuple2)
00750 {
00751 return true;
00752 }
00753
00759 template<typename T1, typename T2>
00760 inline Pair<T1,T2> makePair(const T1& first, const T2& second)
00761 {
00762 return Pair<T1,T2>(first, second);
00763 }
00764
00768 template<typename T1, typename T2>
00769 inline std::ostream& operator<<(std::ostream& os, const Pair<T1,T2>& pair)
00770 {
00771 os<<pair.first()<<" "<<pair.second();
00772 return os;
00773 }
00774
00775 template<typename T1>
00776 inline std::ostream& operator<<(std::ostream& os, const Pair<T1,Nil>& pair)
00777 {
00778 os<<pair.first();
00779 return os;
00780 }
00781
00782 template<class T1>
00783 inline tuple<T1&> tie(T1& t1) {
00784 return tuple<T1&> (t1);
00785 }
00786
00787 template<class T1, class T2>
00788 inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {
00789 return tuple<T1&, T2&> (t1, t2);
00790 }
00791
00792 template<class T1, class T2, class T3>
00793 inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {
00794 return tuple<T1&, T2&, T3&> (t1, t2, t3);
00795 }
00796
00797 template<class T1, class T2, class T3, class T4>
00798 inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
00799 return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);
00800 }
00801
00802 template<class T1, class T2, class T3, class T4, class T5>
00803 inline tuple<T1&, T2&, T3&, T4&, T5&>
00804 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
00805 return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
00806 }
00807
00808 template<class T1, class T2, class T3, class T4, class T5, class T6>
00809 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
00810 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
00811 return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
00812 }
00813
00814 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
00815 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
00816 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
00817 return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
00818 }
00819
00820 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00821 class T8>
00822 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
00823 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
00824 return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
00825 (t1, t2, t3, t4, t5, t6, t7, t8);
00826 }
00827
00828 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00829 class T8, class T9>
00830 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
00831 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9) {
00832 return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
00833 (t1, t2, t3, t4, t5, t6, t7, t8, t9);
00834 }
00835
00836 template<class T1>
00837 inline tuple<T1> make_tuple(const T1& t1) {
00838 return tuple<T1> (t1);
00839 }
00840
00841 template<class T1, class T2>
00842 inline tuple<T1, T2> make_tuple(const T1& t1, const T2& t2) {
00843 return tuple<T1, T2> (t1, t2);
00844 }
00845
00846 template<class T1, class T2, class T3>
00847 inline tuple<T1, T2, T3> make_tuple(const T1& t1, const T2& t2, const T3& t3) {
00848 return tuple<T1, T2, T3> (t1, t2, t3);
00849 }
00850
00851 template<class T1, class T2, class T3, class T4>
00852 inline tuple<T1, T2, T3, T4> make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
00853 return tuple<T1, T2, T3, T4> (t1, t2, t3, t4);
00854 }
00855
00856 template<class T1, class T2, class T3, class T4, class T5>
00857 inline tuple<T1, T2, T3, T4, T5>
00858 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) {
00859 return tuple<T1, T2, T3, T4, T5> (t1, t2, t3, t4, t5);
00860 }
00861
00862 template<class T1, class T2, class T3, class T4, class T5, class T6>
00863 inline tuple<T1, T2, T3, T4, T5, T6>
00864 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) {
00865 return tuple<T1, T2, T3, T4, T5, T6> (t1, t2, t3, t4, t5, t6);
00866 }
00867
00868 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
00869 inline tuple<T1, T2, T3, T4, T5, T6, T7>
00870 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00871 const T7& t7) {
00872 return tuple<T1, T2, T3, T4, T5, T6, T7> (t1, t2, t3, t4, t5, t6, t7);
00873 }
00874
00875 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00876 class T8>
00877 inline tuple<T1, T2, T3, T4, T5, T6, T7, T8>
00878 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00879 const T7& t7, const T8& t8) {
00880 return tuple<T1, T2, T3, T4, T5, T6, T7, T8>
00881 (t1, t2, t3, t4, t5, t6, t7, t8);
00882 }
00883
00884 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00885 class T8, class T9>
00886 inline tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
00887 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00888 const T7& t7, const T8& t8, const T9& t9) {
00889 return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
00890 (t1, t2, t3, t4, t5, t6, t7, t8, t9);
00891 }
00892
00893 template<typename T1, typename TT>
00894 template<typename T2, typename T3, typename T4, typename T5,
00895 typename T6, typename T7, typename T8, typename T9>
00896 inline Pair<T1,TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
00897 T2& t2, T3& t3, T4& t4, T5& t5,
00898 T6& t6, T7& t7, T8& t8, T9& t9)
00899 : first_(first), second_(t2,t3,t4,t5,t6,t7,t8,t9, nullType())
00900 {}
00901
00902 template <typename T1, typename TT>
00903 inline Pair<T1, TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first, TT& second)
00904 : first_(first), second_(second)
00905 {}
00906
00907 template<typename T1, typename T2>
00908 inline Pair<T1,T2>::Pair()
00909 : first_(), second_()
00910 {}
00911
00912 template<typename T1, typename T2>
00913 template<typename U1, typename U2>
00914 inline Pair<T1,T2>::Pair(const Pair<U1,U2>& other)
00915 : first_(other.first_), second_(other.second_)
00916 {}
00917
00918 template<typename T1, typename T2>
00919 template<typename U1, typename U2>
00920 inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair<U1,U2>& other)
00921 {
00922 first_=other.first_;
00923 second_=other.second_;
00924 return *this;
00925 }
00926
00927 template<typename T1, typename T2>
00928 inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair& other)
00929 {
00930 first_=other.first_;
00931 second_=other.second_;
00932 return *this;
00933 }
00934
00935 template<typename T1, typename T2>
00936 inline typename TupleAccessTraits<T1>::NonConstType
00937 Pair<T1,T2>::first()
00938 {
00939 return first_;
00940 }
00941
00942 template<typename T1, typename T2>
00943 inline typename TupleAccessTraits<T1>::ConstType
00944 Pair<T1,T2>::first() const
00945 {
00946 return first_;
00947 }
00948
00949
00950 template<typename T1, typename T2>
00951 inline typename TupleAccessTraits<T2>::NonConstType
00952 Pair<T1,T2>::second()
00953 {
00954 return second_;
00955 }
00956
00957 template<typename T1, typename T2>
00958 inline typename TupleAccessTraits<T2>::ConstType
00959 Pair<T1,T2>::second() const
00960 {
00961 return second_;
00962 }
00963
00964 template<typename T1>
00965 inline Pair<T1,Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
00966 const Nil&, const Nil&, const Nil&, const Nil&,
00967 const Nil&, const Nil&, const Nil&, const Nil&)
00968 : first_(first)
00969 {}
00970
00971 template <typename T1>
00972 inline Pair<T1, Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
00973 const Nil&)
00974 : first_(first)
00975 {}
00976
00977 template<typename T1>
00978 inline Pair<T1,Nil>::Pair()
00979 : first_()
00980 {}
00981
00982 template<typename T1>
00983 template<typename T2>
00984 inline Pair<T1,Nil>::Pair(const Pair<T2,Nil>& other)
00985 : first_(other.first_)
00986 {}
00987
00988 template<typename T1>
00989 template<typename T2>
00990 Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair<T2,Nil>& other)
00991 {
00992 first_ = other.first_;
00993 return *this;
00994 }
00995
00996
00997 template<typename T1>
00998 Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair& other)
00999 {
01000 first_ = other.first_;
01001 return *this;
01002 }
01003
01004 template<typename T1>
01005 inline typename TupleAccessTraits<T1>::NonConstType
01006 Pair<T1,Nil>::first()
01007 {
01008 return first_;
01009 }
01010
01011 template<typename T1>
01012 inline typename TupleAccessTraits<T1>::ConstType
01013 Pair<T1,Nil>::first() const
01014 {
01015 return first_;
01016 }
01017
01018 #endif
01019 }
01020 #endif