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
00009 #ifdef HAVE_TUPLE
00010 #include <tuple>
00011 #elif defined HAVE_TR1_TUPLE
00012 #include <tr1/tuple>
00013 #endif
00014
00015 namespace Dune{
00034 template<class T>
00035 struct TupleAccessTraits
00036 {
00037 typedef typename ConstantVolatileTraits<T>::ConstType& ConstType;
00038 typedef T& NonConstType;
00039 typedef const typename ConstantVolatileTraits<T>::UnqualifiedType& ParameterType;
00040 };
00041
00042 template<class T>
00043 struct TupleAccessTraits<T*>
00044 {
00045 typedef typename ConstantVolatileTraits<T>::ConstType* ConstType;
00046 typedef T* NonConstType;
00047 typedef T* ParameterType;
00048 };
00049
00050 template<class T>
00051 struct TupleAccessTraits<T&>
00052 {
00053 typedef typename ConstantVolatileTraits<T>::ConstType& ConstType;
00054 typedef T& NonConstType;
00055 typedef T& ParameterType;
00056 };
00057
00058 #ifdef HAVE_TUPLE
00059 using std::tuple;
00060 #elif defined HAVE_TR1_TUPLE
00061 using std::tr1::tuple;
00062 #else
00063
00066 struct Nil
00067 {};
00068
00069 namespace
00070 {
00071 inline const Nil nullType()
00072 {
00073 return Nil();
00074 }
00075 }
00076
00082 template<typename T1, typename TT>
00083 struct Pair
00084 {
00088 typedef T1 Type1;
00089
00093 typedef TT Type2;
00094
00095
00096
00097
00098
00099
00100
00114 template<typename T2, typename T3, typename T4, typename T5,
00115 typename T6, typename T7, typename T8, typename T9>
00116 Pair(typename TupleAccessTraits<T1>::ParameterType t1, T2& t2, T3& t3, T4& t4, T5& t5,
00117 T6& t6, T7& t7, T8& t8, T9& t9);
00118
00125 Pair(typename TupleAccessTraits<Type1>::ParameterType t1, TT& t2);
00126
00127 Pair();
00128
00133 template<typename U1, typename U2>
00134 Pair(const Pair<U1,U2>& other);
00135
00140 template<typename U1, typename U2>
00141 Pair& operator=(const Pair<U1,U2>& other);
00142
00143 Pair& operator=(const Pair& other);
00144
00149 typename TupleAccessTraits<Type1>::NonConstType first();
00150
00155 typename TupleAccessTraits<Type1>::ConstType
00156 first() const;
00157
00162 typename TupleAccessTraits<Type2>::NonConstType
00163 second();
00164
00169 typename TupleAccessTraits<Type2>::ConstType
00170 second() const;
00171
00173 Type1 first_;
00175 Type2 second_;
00176
00177 };
00178
00183 template<typename T1>
00184 struct Pair<T1,Nil>
00185 {
00189 typedef T1 Type1;
00190
00196 typedef Nil Type2;
00197
00202 Pair(typename TupleAccessTraits<T1>::ParameterType first, const Nil&, const Nil&, const Nil&, const Nil&,
00203 const Nil&, const Nil&, const Nil&, const Nil&);
00204
00209 Pair(typename TupleAccessTraits<T1>::ParameterType first,
00210 const Nil&);
00211
00212 Pair();
00213
00217 template<typename T2>
00218 Pair(const Pair<T2,Nil>& other);
00219
00223 template<typename T2>
00224 Pair& operator=(const Pair<T2,Nil>& other);
00225
00229 Pair& operator=(const Pair& other);
00230
00235 typename TupleAccessTraits<Type1>::NonConstType
00236 first();
00237
00242 typename TupleAccessTraits<Type1>::ConstType
00243 first() const;
00244
00246 Type1 first_;
00247 };
00248
00249
00253 template<typename T1, typename T2, typename T3, typename T4, typename T5,
00254 typename T6, typename T7, typename T8, typename T9>
00255 struct TupleToPairs
00256 {
00257 typedef Pair<T1, typename TupleToPairs<T2,T3,T4,T5,T6,T7,T8,T9,Nil>::Type > Type;
00258 };
00259
00263 template<typename T1>
00264 struct TupleToPairs<T1,Nil,Nil,Nil,Nil,Nil,Nil,Nil,Nil>
00265 {
00266 typedef Pair<T1,Nil> Type;
00267 };
00268
00286 template<typename T1, typename T2 = Nil, typename T3 = Nil,
00287 typename T4 = Nil, typename T5 = Nil,typename T6 = Nil,
00288 typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
00289 class tuple : public TupleToPairs<T1,T2,T3,T4,T5,T6,T7,T8,T9>::Type
00290 {
00291 public:
00293 typedef typename TupleToPairs<T1,T2,T3,T4,T5,T6,T7,T8,T9>::Type FirstPair;
00294
00295 tuple()
00296 {}
00297
00298 tuple(typename TupleAccessTraits<T1>::ParameterType t1)
00299 : FirstPair(t1, nullType(), nullType(), nullType(),
00300 nullType(), nullType(), nullType(), nullType(),
00301 nullType())
00302 {}
00303
00304 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00305 typename TupleAccessTraits<T2>::ParameterType t2)
00306 : FirstPair(t1, t2, nullType(), nullType(),
00307 nullType(), nullType(), nullType(), nullType(),
00308 nullType())
00309 {}
00310
00311 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00312 typename TupleAccessTraits<T2>::ParameterType t2,
00313 typename TupleAccessTraits<T3>::ParameterType t3)
00314 : FirstPair(t1, t2, t3, nullType(),
00315 nullType(), nullType(), nullType(), nullType(),
00316 nullType())
00317 {}
00318
00319 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00320 typename TupleAccessTraits<T2>::ParameterType t2,
00321 typename TupleAccessTraits<T3>::ParameterType t3,
00322 typename TupleAccessTraits<T4>::ParameterType t4)
00323 : FirstPair(t1, t2, t3, t4,
00324 nullType(), nullType(), nullType(), nullType(),
00325 nullType())
00326 {}
00327
00328 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00329 typename TupleAccessTraits<T2>::ParameterType t2,
00330 typename TupleAccessTraits<T3>::ParameterType t3,
00331 typename TupleAccessTraits<T4>::ParameterType t4,
00332 typename TupleAccessTraits<T5>::ParameterType t5)
00333 : FirstPair(t1, t2, t3, t4,
00334 t5, nullType(), nullType(), nullType(),
00335 nullType())
00336 {}
00337
00338 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00339 typename TupleAccessTraits<T2>::ParameterType t2,
00340 typename TupleAccessTraits<T3>::ParameterType t3,
00341 typename TupleAccessTraits<T4>::ParameterType t4,
00342 typename TupleAccessTraits<T5>::ParameterType t5,
00343 typename TupleAccessTraits<T6>::ParameterType t6)
00344 : FirstPair(t1, t2, t3, t4,
00345 t5, t6, nullType(), nullType(),
00346 nullType())
00347 {}
00348
00349 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00350 typename TupleAccessTraits<T2>::ParameterType t2,
00351 typename TupleAccessTraits<T3>::ParameterType t3,
00352 typename TupleAccessTraits<T4>::ParameterType t4,
00353 typename TupleAccessTraits<T5>::ParameterType t5,
00354 typename TupleAccessTraits<T6>::ParameterType t6,
00355 typename TupleAccessTraits<T7>::ParameterType t7)
00356 : FirstPair(t1, t2, t3, t4,
00357 t5, t6, t7, nullType(),
00358 nullType())
00359 {}
00360
00361 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00362 typename TupleAccessTraits<T2>::ParameterType t2,
00363 typename TupleAccessTraits<T3>::ParameterType t3,
00364 typename TupleAccessTraits<T4>::ParameterType t4,
00365 typename TupleAccessTraits<T5>::ParameterType t5,
00366 typename TupleAccessTraits<T6>::ParameterType t6,
00367 typename TupleAccessTraits<T7>::ParameterType t7,
00368 typename TupleAccessTraits<T8>::ParameterType t8)
00369 : FirstPair(t1, t2, t3, t4,
00370 t5, t6, t7, t8,
00371 nullType())
00372 {}
00373
00374 tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00375 typename TupleAccessTraits<T2>::ParameterType t2,
00376 typename TupleAccessTraits<T3>::ParameterType t3,
00377 typename TupleAccessTraits<T4>::ParameterType t4,
00378 typename TupleAccessTraits<T5>::ParameterType t5,
00379 typename TupleAccessTraits<T6>::ParameterType t6,
00380 typename TupleAccessTraits<T7>::ParameterType t7,
00381 typename TupleAccessTraits<T8>::ParameterType t8,
00382 typename TupleAccessTraits<T9>::ParameterType t9)
00383 : FirstPair(t1, t2, t3, t4, t5, t6, t7, t8, t9)
00384 {}
00385
00386 template<class U1, class U2>
00387 tuple& operator=(const Pair<U1,U2>& other)
00388 {
00389 FirstPair::operator=(other);
00390 return *this;
00391 }
00392 };
00393
00394 #endif
00395
00396 #ifdef HAVE_TUPLE
00397 using std::tuple_element;
00398 #elif defined HAVE_TR1_TUPLE
00399 using std::tr1::tuple_element;
00400 #else
00401
00404 template<int N, class Tuple>
00405 struct tuple_element
00406 {
00410 typedef typename tuple_element<N,typename Tuple::FirstPair>::type type;
00411 typedef typename tuple_element<N,typename Tuple::FirstPair>::type Type;
00412 };
00413
00414 template<int N, typename T1, typename T2>
00415 struct tuple_element<N,Pair<T1,T2> >
00416 {
00420 typedef typename tuple_element<N-1,T2>::Type type;
00421 typedef typename tuple_element<N-1,T2>::Type Type;
00422 };
00423
00427 template<typename T1, typename T2>
00428 struct tuple_element<0, Pair<T1,T2> >
00429 {
00433 typedef T1 type;
00434 typedef T1 Type;
00435 };
00436
00437 #endif
00438
00439 template< int N, class T >
00440 struct ElementType
00441 {
00442 typedef typename tuple_element< N, T > :: type Type DUNE_DEPRECATED;
00443 };
00444
00445 #if defined HAVE_TUPLE || defined HAVE_TR1_TUPLE
00446 #ifdef HAVE_TUPLE
00447 #define TUPLE_NS std
00448 using std::get;
00449 #elif defined HAVE_TR1_TUPLE
00450 #define TUPLE_NS std::tr1
00451 using std::tr1::get;
00452 #endif
00453
00454
00455 template<int i>
00456 struct Element{
00457 template<typename T1>
00458 static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::NonConstType get(T1& t)
00459 {
00460 return TUPLE_NS::get<i>(t);
00461 }
00462
00463 template<typename T1>
00464 static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::ConstType get(const T1& t)
00465 {
00466 return TUPLE_NS::get<i>(t);
00467 }
00468 };
00469 #undef TUPLE_NS
00470
00471 #else
00472
00475 template<int N>
00476 struct Element
00477 {
00483 template<typename T1, typename T2>
00484 static typename TupleAccessTraits<
00485 typename tuple_element<N,Pair<T1,T2> >::type
00486 >::NonConstType
00487 get(Pair<T1,T2>& tuple)
00488 {
00489 return Element<N-1>::get(tuple.second());
00490 }
00491
00497 template<typename T1, typename T2>
00498 static typename TupleAccessTraits<
00499 typename tuple_element<N,Pair<T1,T2> >::type
00500 >::ConstType
00501 get(const Pair<T1,T2>& tuple)
00502 {
00503 return Element<N-1>::get(tuple.second());
00504 }
00505 };
00506
00510 template<>
00511 struct Element<0>
00512 {
00518 template<typename T1, typename T2>
00519 static typename TupleAccessTraits<T1>::NonConstType get(Pair<T1,T2>& tuple)
00520 {
00521 return tuple.first();
00522 }
00523
00529 template<typename T1, typename T2>
00530 static typename TupleAccessTraits<T1>::ConstType get(const Pair<T1,T2>& tuple)
00531 {
00532 return tuple.first();
00533 }
00534 };
00535
00536 template<int i, typename T1, typename T2, typename T3, typename T4,
00537 typename T5, typename T6, typename T7, typename T8, typename T9>
00538 typename TupleAccessTraits<typename tuple_element<i, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::type>
00539 ::NonConstType
00540 get(tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>& t)
00541 {
00542 return Element<i>::get(t);
00543 }
00544
00545 template<int i, typename T1, typename T2, typename T3, typename T4,
00546 typename T5, typename T6, typename T7, typename T8, typename T9>
00547 typename TupleAccessTraits<typename tuple_element<i, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::type>
00548 ::ConstType
00549 get(const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>& t)
00550 {
00551 return Element<i>::get(t);
00552 }
00553
00554 #endif
00555
00556 #ifdef HAVE_TUPLE
00557 using std::tuple_size;
00558 #elif defined HAVE_TR1_TUPLE
00559 using std::tr1::tuple_size;
00560 #else
00561
00565 template<class T>
00566 struct tuple_size
00567 {
00568 enum{
00569
00570 value=tuple_size<typename T::FirstPair>::value
00571 };
00572
00573
00574 };
00575
00576 template<typename T1, typename T2>
00577 struct tuple_size<Pair<T1,T2> >
00578 {
00579 enum{ value=1+tuple_size<T2>::value};
00580 };
00581
00582
00583 template<typename T1>
00584 struct tuple_size<Pair<T1,Nil> >
00585 {
00586 enum{ value=1};
00587 };
00588
00589 template<>
00590 struct tuple_size<Pair<Nil,Nil> >
00591 {
00592 enum{ value=0};
00593 };
00594 #endif
00595 template<typename T>
00596 struct Size : public tuple_size<T>
00597 {
00598 };
00599
00600
00601 #ifdef HAVE_TUPLE
00602 using std::tie;
00603 using std::make_tuple;
00604 #elif defined HAVE_TR1_TUPLE
00605 using std::tr1::tie;
00606 using std::tr1::make_tuple;
00607 #endif
00608
00609
00610 template<int i>
00611 struct tuple_writer
00612 {
00613 template<class T>
00614 static std::ostream& put(std::ostream& os, const T& t, const char* delim=", ")
00615 {
00616 return tuple_writer<i-1>::put(os,t,delim)<<delim<<get<i-1>(t);
00617 }
00618 };
00619
00620 template<>
00621 struct tuple_writer<1>
00622 {
00623 template<class T>
00624 static std::ostream& put(std::ostream& os, const T& t, const char* delim=", ")
00625 {
00626 return os<<get<0>(t);
00627 }
00628 };
00629
00630 template<>
00631 struct tuple_writer<0>
00632 {
00633 template<class T>
00634 static std::ostream& put(std::ostream& os, const T& t, const char* delim=", ")
00635 {
00636 return os;
00637 }
00638 };
00639
00640 #if defined HAVE_TUPLE || defined HAVE_TR1_TUPLE
00641
00644 template<typename T1>
00645 inline std::ostream& operator<<( std::ostream& os, const tuple<T1> & t)
00646 {
00647 typedef tuple<T1> TupleT;
00648 return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00649 }
00650
00651 template<typename T1, typename T2>
00652 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2> & t)
00653 {
00654 typedef tuple<T1,T2> TupleT;
00655 return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00656 }
00657
00658 template<typename T1, typename T2, typename T3>
00659 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3> & t)
00660 {
00661 typedef tuple<T1,T2,T3> TupleT;
00662 return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00663 }
00664
00665 template<typename T1, typename T2, typename T3, typename T4>
00666 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4> & t)
00667 {
00668 typedef tuple<T1,T2,T3,T4> TupleT;
00669 return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00670 }
00671
00672 template<typename T1, typename T2, typename T3, typename T4, typename T5>
00673 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5> & t)
00674 {
00675 typedef tuple<T1,T2,T3,T4,T5> TupleT;
00676 return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00677 }
00678
00679 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
00680 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6> & t)
00681 {
00682 typedef tuple<T1,T2,T3,T4,T5,T6> TupleT;
00683 return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00684 }
00685
00686 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
00687 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7> & t)
00688 {
00689 typedef tuple<T1,T2,T3,T4,T5,T6,T7> TupleT;
00690 return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00691 }
00692
00693 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
00694 typename T8>
00695 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8> & t)
00696 {
00697 typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8> TupleT;
00698 return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00699 }
00700
00701 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
00702 typename T8, typename T9>
00703 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> & t)
00704 {
00705 typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> TupleT;
00706 return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00707 }
00708
00709 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
00710 typename T8, typename T9, typename T10>
00711 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> & t)
00712 {
00713 typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> TupleT;
00714 return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00715 }
00716
00717 #else
00718
00723 template<typename T1, typename T2, typename U1, typename U2>
00724 inline bool operator==(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00725 {
00726 return (tuple1.first()==tuple2.first() && tuple1.second()==tuple2.second());
00727 }
00728
00734 template<typename T1, typename T2, typename U1, typename U2>
00735 inline bool operator!=(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00736 {
00737 return (tuple1.first()!=tuple2.first() || tuple1.second()!=tuple2.second());
00738 }
00739
00745 template<typename T1, typename T2, typename U1, typename U2>
00746 inline bool operator<(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00747 {
00748 return tuple1.first() < tuple2.first()
00749 || (tuple1.first() == tuple2.first() && tuple1.second() < tuple2.second());
00750 }
00751
00757 template<typename T1,typename U1>
00758 inline bool operator==(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00759 {
00760 return (tuple1.first()==tuple2.first());
00761 }
00762
00768 template<typename T1, typename U1>
00769 inline bool operator!=(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00770 {
00771 dune_static_assert( (IsInteroperable<T1,U1>::value),
00772 "T1 and U1 have to be interoperable, i.e., either "
00773 "conversion from one to the other must exist." );
00774 return (tuple1.first()!=tuple2.first());
00775 }
00776
00782 template<typename T1, typename U1>
00783 inline bool operator<(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00784 {
00785 return (tuple1.first()<tuple2.first());
00786 }
00787
00795 template<typename T1,typename U1, typename U2>
00796 inline bool operator==(const Pair<T1,Nil>& tuple1, const Pair<U1,U2>& tuple2)
00797 {
00798 return false;
00799 }
00800
00807 template<typename T1, typename U1, typename U2>
00808 inline bool operator!=(const Pair<T1,Nil>& tuple1, const Pair<U1,U2>& tuple2)
00809 {
00810 return true;
00811 }
00812
00813
00820 template<typename T1, typename T2, typename U1>
00821 inline bool operator==(const Pair<T1,T2>& tuple1, const Pair<U1,Nil>& tuple2)
00822 {
00823 return false;
00824 }
00825
00832 template<typename T1, typename T2, typename U1>
00833 inline bool operator!=(const Pair<T1,T2>& tuple1, const Pair<U1,Nil>& tuple2)
00834 {
00835 return true;
00836 }
00837
00843 template<typename T1, typename T2>
00844 inline Pair<T1,T2> makePair(const T1& first, const T2& second)
00845 {
00846 return Pair<T1,T2>(first, second);
00847 }
00848
00852 template<typename T1, typename T2>
00853 inline std::ostream& operator<<(std::ostream& os, const Pair<T1,T2>& pair)
00854 {
00855 os<<pair.first()<<" "<<pair.second();
00856 return os;
00857 }
00858
00859 template<typename T1>
00860 inline std::ostream& operator<<(std::ostream& os, const Pair<T1,Nil>& pair)
00861 {
00862 os<<pair.first();
00863 return os;
00864 }
00865
00866 template<class T1>
00867 inline tuple<T1&> tie(T1& t1) {
00868 return tuple<T1&> (t1);
00869 }
00870
00871 template<class T1, class T2>
00872 inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {
00873 return tuple<T1&, T2&> (t1, t2);
00874 }
00875
00876 template<class T1, class T2, class T3>
00877 inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {
00878 return tuple<T1&, T2&, T3&> (t1, t2, t3);
00879 }
00880
00881 template<class T1, class T2, class T3, class T4>
00882 inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
00883 return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);
00884 }
00885
00886 template<class T1, class T2, class T3, class T4, class T5>
00887 inline tuple<T1&, T2&, T3&, T4&, T5&>
00888 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
00889 return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
00890 }
00891
00892 template<class T1, class T2, class T3, class T4, class T5, class T6>
00893 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
00894 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
00895 return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
00896 }
00897
00898 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
00899 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
00900 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
00901 return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
00902 }
00903
00904 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00905 class T8>
00906 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
00907 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
00908 return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
00909 (t1, t2, t3, t4, t5, t6, t7, t8);
00910 }
00911
00912 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00913 class T8, class T9>
00914 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
00915 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9) {
00916 return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
00917 (t1, t2, t3, t4, t5, t6, t7, t8, t9);
00918 }
00919
00920 template<class T1>
00921 inline tuple<T1> make_tuple(const T1& t1) {
00922 return tuple<T1> (t1);
00923 }
00924
00925 template<class T1, class T2>
00926 inline tuple<T1, T2> make_tuple(const T1& t1, const T2& t2) {
00927 return tuple<T1, T2> (t1, t2);
00928 }
00929
00930 template<class T1, class T2, class T3>
00931 inline tuple<T1, T2, T3> make_tuple(const T1& t1, const T2& t2, const T3& t3) {
00932 return tuple<T1, T2, T3> (t1, t2, t3);
00933 }
00934
00935 template<class T1, class T2, class T3, class T4>
00936 inline tuple<T1, T2, T3, T4> make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
00937 return tuple<T1, T2, T3, T4> (t1, t2, t3, t4);
00938 }
00939
00940 template<class T1, class T2, class T3, class T4, class T5>
00941 inline tuple<T1, T2, T3, T4, T5>
00942 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) {
00943 return tuple<T1, T2, T3, T4, T5> (t1, t2, t3, t4, t5);
00944 }
00945
00946 template<class T1, class T2, class T3, class T4, class T5, class T6>
00947 inline tuple<T1, T2, T3, T4, T5, T6>
00948 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) {
00949 return tuple<T1, T2, T3, T4, T5, T6> (t1, t2, t3, t4, t5, t6);
00950 }
00951
00952 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
00953 inline tuple<T1, T2, T3, T4, T5, T6, T7>
00954 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00955 const T7& t7) {
00956 return tuple<T1, T2, T3, T4, T5, T6, T7> (t1, t2, t3, t4, t5, t6, t7);
00957 }
00958
00959 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00960 class T8>
00961 inline tuple<T1, T2, T3, T4, T5, T6, T7, T8>
00962 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00963 const T7& t7, const T8& t8) {
00964 return tuple<T1, T2, T3, T4, T5, T6, T7, T8>
00965 (t1, t2, t3, t4, t5, t6, t7, t8);
00966 }
00967
00968 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00969 class T8, class T9>
00970 inline tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
00971 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00972 const T7& t7, const T8& t8, const T9& t9) {
00973 return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
00974 (t1, t2, t3, t4, t5, t6, t7, t8, t9);
00975 }
00976
00977 template<typename T1, typename TT>
00978 template<typename T2, typename T3, typename T4, typename T5,
00979 typename T6, typename T7, typename T8, typename T9>
00980 inline Pair<T1,TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
00981 T2& t2, T3& t3, T4& t4, T5& t5,
00982 T6& t6, T7& t7, T8& t8, T9& t9)
00983 : first_(first), second_(t2,t3,t4,t5,t6,t7,t8,t9, nullType())
00984 {}
00985
00986 template <typename T1, typename TT>
00987 inline Pair<T1, TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first, TT& second)
00988 : first_(first), second_(second)
00989 {}
00990
00991 template<typename T1, typename T2>
00992 inline Pair<T1,T2>::Pair()
00993 : first_(), second_()
00994 {}
00995
00996 template<typename T1, typename T2>
00997 template<typename U1, typename U2>
00998 inline Pair<T1,T2>::Pair(const Pair<U1,U2>& other)
00999 : first_(other.first_), second_(other.second_)
01000 {}
01001
01002 template<typename T1, typename T2>
01003 template<typename U1, typename U2>
01004 inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair<U1,U2>& other)
01005 {
01006 first_=other.first_;
01007 second_=other.second_;
01008 return *this;
01009 }
01010
01011 template<typename T1, typename T2>
01012 inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair& other)
01013 {
01014 first_=other.first_;
01015 second_=other.second_;
01016 return *this;
01017 }
01018
01019 template<typename T1, typename T2>
01020 inline typename TupleAccessTraits<T1>::NonConstType
01021 Pair<T1,T2>::first()
01022 {
01023 return first_;
01024 }
01025
01026 template<typename T1, typename T2>
01027 inline typename TupleAccessTraits<T1>::ConstType
01028 Pair<T1,T2>::first() const
01029 {
01030 return first_;
01031 }
01032
01033
01034 template<typename T1, typename T2>
01035 inline typename TupleAccessTraits<T2>::NonConstType
01036 Pair<T1,T2>::second()
01037 {
01038 return second_;
01039 }
01040
01041 template<typename T1, typename T2>
01042 inline typename TupleAccessTraits<T2>::ConstType
01043 Pair<T1,T2>::second() const
01044 {
01045 return second_;
01046 }
01047
01048 template<typename T1>
01049 inline Pair<T1,Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
01050 const Nil&, const Nil&, const Nil&, const Nil&,
01051 const Nil&, const Nil&, const Nil&, const Nil&)
01052 : first_(first)
01053 {}
01054
01055 template <typename T1>
01056 inline Pair<T1, Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
01057 const Nil&)
01058 : first_(first)
01059 {}
01060
01061 template<typename T1>
01062 inline Pair<T1,Nil>::Pair()
01063 : first_()
01064 {}
01065
01066 template<typename T1>
01067 template<typename T2>
01068 inline Pair<T1,Nil>::Pair(const Pair<T2,Nil>& other)
01069 : first_(other.first_)
01070 {}
01071
01072 template<typename T1>
01073 template<typename T2>
01074 Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair<T2,Nil>& other)
01075 {
01076 first_ = other.first_;
01077 return *this;
01078 }
01079
01080
01081 template<typename T1>
01082 Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair& other)
01083 {
01084 first_ = other.first_;
01085 return *this;
01086 }
01087
01088 template<typename T1>
01089 inline typename TupleAccessTraits<T1>::NonConstType
01090 Pair<T1,Nil>::first()
01091 {
01092 return first_;
01093 }
01094
01095 template<typename T1>
01096 inline typename TupleAccessTraits<T1>::ConstType
01097 Pair<T1,Nil>::first() const
01098 {
01099 return first_;
01100 }
01101
01102 #endif
01103 }
01104 #endif