dune-common 2.1.1
|
00001 // -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- 00002 // vi: set ts=8 sw=2 et sts=2: 00003 00004 #ifndef DUNE_TUPLES_HH 00005 #define DUNE_TUPLES_HH 00006 00007 #include<iostream> 00008 00009 #include <dune/common/deprecated.hh> 00010 #include"typetraits.hh" 00011 #include"static_assert.hh" 00012 00013 #ifdef HAVE_TUPLE 00014 #include <tuple> 00015 #elif defined HAVE_TR1_TUPLE 00016 #include <tr1/tuple> 00017 #endif 00018 00019 namespace Dune{ 00038 template<class T> 00039 struct TupleAccessTraits 00040 { 00041 typedef typename ConstantVolatileTraits<T>::ConstType& ConstType; 00042 typedef T& NonConstType; 00043 typedef const typename ConstantVolatileTraits<T>::UnqualifiedType& ParameterType; 00044 }; 00045 00046 template<class T> 00047 struct TupleAccessTraits<T*> 00048 { 00049 typedef typename ConstantVolatileTraits<T>::ConstType* ConstType; 00050 typedef T* NonConstType; 00051 typedef T* ParameterType; 00052 }; 00053 00054 template<class T> 00055 struct TupleAccessTraits<T&> 00056 { 00057 typedef T& ConstType; 00058 typedef T& NonConstType; 00059 typedef T& ParameterType; 00060 }; 00061 00062 #ifdef HAVE_TUPLE 00063 using std::tuple; 00064 #elif defined HAVE_TR1_TUPLE 00065 using std::tr1::tuple; 00066 #else 00067 00070 struct Nil 00071 {}; 00072 00073 namespace 00074 { 00075 inline const Nil nullType() 00076 { 00077 return Nil(); 00078 } 00079 } 00080 00086 template<typename T1, typename TT> 00087 struct Pair 00088 { 00092 typedef T1 Type1; 00093 00097 typedef TT Type2; 00098 // enum{ 00099 // /** 00100 // * @brief The number of values we hold. 00101 // */ 00102 // values = 2; 00103 // }; 00104 00118 template<typename T2, typename T3, typename T4, typename T5, 00119 typename T6, typename T7, typename T8, typename T9> 00120 Pair(typename TupleAccessTraits<T1>::ParameterType t1, T2& t2, T3& t3, T4& t4, T5& t5, 00121 T6& t6, T7& t7, T8& t8, T9& t9); 00122 00129 Pair(typename TupleAccessTraits<Type1>::ParameterType t1, TT& t2); 00130 00131 Pair(); 00132 00137 template<typename U1, typename U2> 00138 Pair(const Pair<U1,U2>& other); 00139 00144 template<typename U1, typename U2> 00145 Pair& operator=(const Pair<U1,U2>& other); 00146 00147 Pair& operator=(const Pair& other); 00148 00153 typename TupleAccessTraits<Type1>::NonConstType first(); 00154 00159 typename TupleAccessTraits<Type1>::ConstType 00160 first() const; 00161 00166 typename TupleAccessTraits<Type2>::NonConstType 00167 second(); 00168 00173 typename TupleAccessTraits<Type2>::ConstType 00174 second() const; 00175 00177 Type1 first_; 00179 Type2 second_; 00180 00181 }; 00182 00187 template<typename T1> 00188 struct Pair<T1,Nil> 00189 { 00193 typedef T1 Type1; 00194 00200 typedef Nil Type2; 00201 00206 Pair(typename TupleAccessTraits<T1>::ParameterType first, const Nil&, const Nil&, const Nil&, const Nil&, 00207 const Nil&, const Nil&, const Nil&, const Nil&); 00208 00213 Pair(typename TupleAccessTraits<T1>::ParameterType first, 00214 const Nil&); 00215 00216 Pair(); 00217 00221 template<typename T2> 00222 Pair(const Pair<T2,Nil>& other); 00223 00227 template<typename T2> 00228 Pair& operator=(const Pair<T2,Nil>& other); 00229 00233 Pair& operator=(const Pair& other); 00234 00239 typename TupleAccessTraits<Type1>::NonConstType 00240 first(); 00241 00246 typename TupleAccessTraits<Type1>::ConstType 00247 first() const; 00248 00250 Type1 first_; 00251 }; 00252 00253 00257 template<typename T1, typename T2, typename T3, typename T4, typename T5, 00258 typename T6, typename T7, typename T8, typename T9> 00259 struct TupleToPairs 00260 { 00261 typedef Pair<T1, typename TupleToPairs<T2,T3,T4,T5,T6,T7,T8,T9,Nil>::Type > Type; 00262 }; 00263 00267 template<typename T1> 00268 struct TupleToPairs<T1,Nil,Nil,Nil,Nil,Nil,Nil,Nil,Nil> 00269 { 00270 typedef Pair<T1,Nil> Type; 00271 }; 00272 00290 template<typename T1 = Nil, typename T2 = Nil, typename T3 = Nil, 00291 typename T4 = Nil, typename T5 = Nil,typename T6 = Nil, 00292 typename T7 = Nil, typename T8 = Nil, typename T9 = Nil> 00293 class tuple : public TupleToPairs<T1,T2,T3,T4,T5,T6,T7,T8,T9>::Type 00294 { 00295 public: 00297 typedef typename TupleToPairs<T1,T2,T3,T4,T5,T6,T7,T8,T9>::Type FirstPair; 00298 00299 tuple() 00300 {} 00301 00302 tuple(typename TupleAccessTraits<T1>::ParameterType t1) 00303 : FirstPair(t1, nullType(), nullType(), nullType(), 00304 nullType(), nullType(), nullType(), nullType(), 00305 nullType()) 00306 {} 00307 00308 tuple(typename TupleAccessTraits<T1>::ParameterType t1, 00309 typename TupleAccessTraits<T2>::ParameterType t2) 00310 : FirstPair(t1, t2, nullType(), 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 : FirstPair(t1, t2, t3, nullType(), 00319 nullType(), nullType(), nullType(), nullType(), 00320 nullType()) 00321 {} 00322 00323 tuple(typename TupleAccessTraits<T1>::ParameterType t1, 00324 typename TupleAccessTraits<T2>::ParameterType t2, 00325 typename TupleAccessTraits<T3>::ParameterType t3, 00326 typename TupleAccessTraits<T4>::ParameterType t4) 00327 : FirstPair(t1, t2, t3, t4, 00328 nullType(), nullType(), nullType(), nullType(), 00329 nullType()) 00330 {} 00331 00332 tuple(typename TupleAccessTraits<T1>::ParameterType t1, 00333 typename TupleAccessTraits<T2>::ParameterType t2, 00334 typename TupleAccessTraits<T3>::ParameterType t3, 00335 typename TupleAccessTraits<T4>::ParameterType t4, 00336 typename TupleAccessTraits<T5>::ParameterType t5) 00337 : FirstPair(t1, t2, t3, t4, 00338 t5, nullType(), nullType(), nullType(), 00339 nullType()) 00340 {} 00341 00342 tuple(typename TupleAccessTraits<T1>::ParameterType t1, 00343 typename TupleAccessTraits<T2>::ParameterType t2, 00344 typename TupleAccessTraits<T3>::ParameterType t3, 00345 typename TupleAccessTraits<T4>::ParameterType t4, 00346 typename TupleAccessTraits<T5>::ParameterType t5, 00347 typename TupleAccessTraits<T6>::ParameterType t6) 00348 : FirstPair(t1, t2, t3, t4, 00349 t5, t6, nullType(), nullType(), 00350 nullType()) 00351 {} 00352 00353 tuple(typename TupleAccessTraits<T1>::ParameterType t1, 00354 typename TupleAccessTraits<T2>::ParameterType t2, 00355 typename TupleAccessTraits<T3>::ParameterType t3, 00356 typename TupleAccessTraits<T4>::ParameterType t4, 00357 typename TupleAccessTraits<T5>::ParameterType t5, 00358 typename TupleAccessTraits<T6>::ParameterType t6, 00359 typename TupleAccessTraits<T7>::ParameterType t7) 00360 : FirstPair(t1, t2, t3, t4, 00361 t5, t6, t7, nullType(), 00362 nullType()) 00363 {} 00364 00365 tuple(typename TupleAccessTraits<T1>::ParameterType t1, 00366 typename TupleAccessTraits<T2>::ParameterType t2, 00367 typename TupleAccessTraits<T3>::ParameterType t3, 00368 typename TupleAccessTraits<T4>::ParameterType t4, 00369 typename TupleAccessTraits<T5>::ParameterType t5, 00370 typename TupleAccessTraits<T6>::ParameterType t6, 00371 typename TupleAccessTraits<T7>::ParameterType t7, 00372 typename TupleAccessTraits<T8>::ParameterType t8) 00373 : FirstPair(t1, t2, t3, t4, 00374 t5, t6, t7, t8, 00375 nullType()) 00376 {} 00377 00378 tuple(typename TupleAccessTraits<T1>::ParameterType t1, 00379 typename TupleAccessTraits<T2>::ParameterType t2, 00380 typename TupleAccessTraits<T3>::ParameterType t3, 00381 typename TupleAccessTraits<T4>::ParameterType t4, 00382 typename TupleAccessTraits<T5>::ParameterType t5, 00383 typename TupleAccessTraits<T6>::ParameterType t6, 00384 typename TupleAccessTraits<T7>::ParameterType t7, 00385 typename TupleAccessTraits<T8>::ParameterType t8, 00386 typename TupleAccessTraits<T9>::ParameterType t9) 00387 : FirstPair(t1, t2, t3, t4, t5, t6, t7, t8, t9) 00388 {} 00389 00390 template<class U1, class U2> 00391 tuple& operator=(const Pair<U1,U2>& other) 00392 { 00393 FirstPair::operator=(other); 00394 return *this; 00395 } 00396 }; 00397 00398 #endif 00399 00400 #ifdef HAVE_TUPLE 00401 using std::tuple_element; 00402 #elif defined HAVE_TR1_TUPLE 00403 using std::tr1::tuple_element; 00404 #else 00405 00408 template<int N, class Tuple> 00409 struct tuple_element 00410 { 00414 typedef typename tuple_element<N,typename Tuple::FirstPair>::type type; 00415 typedef typename tuple_element<N,typename Tuple::FirstPair>::type Type; 00416 }; 00417 00418 template<int N, typename T1, typename T2> 00419 struct tuple_element<N,Pair<T1,T2> > 00420 { 00424 typedef typename tuple_element<N-1,T2>::Type type; 00425 typedef typename tuple_element<N-1,T2>::Type Type; 00426 }; 00427 00431 template<typename T1, typename T2> 00432 struct tuple_element<0, Pair<T1,T2> > 00433 { 00437 typedef T1 type; 00438 typedef T1 Type; 00439 }; 00440 00441 #endif 00442 00443 template< int N, class T > 00444 struct ElementType 00445 { 00446 typedef typename tuple_element< N, T > :: type Type DUNE_DEPRECATED; 00447 }; 00448 00449 #if defined HAVE_TUPLE || defined HAVE_TR1_TUPLE 00450 #ifdef HAVE_TUPLE 00451 #define TUPLE_NS std 00452 using std::get; 00453 #elif defined HAVE_TR1_TUPLE 00454 #define TUPLE_NS std::tr1 00455 using std::tr1::get; 00456 #endif 00457 00458 // for backwards compatibility 00459 template<int i> 00460 struct Element{ 00461 template<typename T1> 00462 static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::NonConstType get(T1& t) 00463 { 00464 return TUPLE_NS::get<i>(t); 00465 } 00466 00467 template<typename T1> 00468 static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::ConstType get(const T1& t) 00469 { 00470 return TUPLE_NS::get<i>(t); 00471 } 00472 }; 00473 #undef TUPLE_NS 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 template<int i, typename T1, typename T2, typename T3, typename T4, 00550 typename T5, typename T6, typename T7, typename T8, typename T9> 00551 typename TupleAccessTraits<typename tuple_element<i, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::type> 00552 ::ConstType 00553 get(const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>& t) 00554 { 00555 return Element<i>::get(t); 00556 } 00557 00558 #endif 00559 00560 #ifdef HAVE_TUPLE 00561 using std::tuple_size; 00562 #elif defined HAVE_TR1_TUPLE 00563 using std::tr1::tuple_size; 00564 #else 00565 00569 template<class T> 00570 struct tuple_size 00571 { 00572 enum{ 00573 // @brief The number of Elements in the tuple. 00574 value=tuple_size<typename T::FirstPair>::value 00575 }; 00576 00577 00578 }; 00579 00580 template<typename T1, typename T2> 00581 struct tuple_size<Pair<T1,T2> > 00582 { 00583 enum{ value=1+tuple_size<T2>::value}; 00584 }; 00585 00586 00587 template<typename T1> 00588 struct tuple_size<Pair<T1,Nil> > 00589 { 00590 enum{ value=1}; 00591 }; 00592 00593 template<> 00594 struct tuple_size<Pair<Nil,Nil> > 00595 { 00596 enum{ value=0}; 00597 }; 00598 #endif 00599 template<typename T> 00600 struct Size : public tuple_size<T> 00601 { 00602 }; 00603 00604 00605 #ifdef HAVE_TUPLE 00606 using std::tie; 00607 using std::make_tuple; 00608 #elif defined HAVE_TR1_TUPLE 00609 using std::tr1::tie; 00610 using std::tr1::make_tuple; 00611 #endif 00612 00613 00614 template<int i> 00615 struct tuple_writer 00616 { 00617 template<class T> 00618 static std::ostream& put(std::ostream& os, const T& t, const char* delim=", ") 00619 { 00620 return tuple_writer<i-1>::put(os,t,delim)<<delim<<Dune::get<i-1>(t); 00621 } 00622 00623 template< class T > 00624 static std::istream &get ( std::istream &is, T &t, const char *delim = "," ) 00625 { 00626 tuple_writer< i-1 >::get( is, t, delim ); 00627 for( const char *it = delim; is && (*it != 0); ++it ) 00628 { 00629 char c = 0; 00630 is >> c; 00631 if( c != *it ) 00632 is.setstate( std::ios::failbit ); 00633 } 00634 return is >> Dune::get< i-1 >( t ); 00635 } 00636 }; 00637 00638 template<> 00639 struct tuple_writer<1> 00640 { 00641 template<class T> 00642 static std::ostream& put(std::ostream& os, const T& t, const char* delim=", ") 00643 { 00644 return os<<Dune::get<0>(t); 00645 } 00646 00647 template< class T > 00648 static std::istream &get ( std::istream &is, T &t, const char *delim = ", " ) 00649 { 00650 return is >> Dune::get< 0 >( t ); 00651 } 00652 }; 00653 00654 template<> 00655 struct tuple_writer<0> 00656 { 00657 template<class T> 00658 static std::ostream& put(std::ostream& os, const T& t, const char* delim=", ") 00659 { 00660 return os; 00661 } 00662 00663 template< class T > 00664 static std::istream &get ( std::istream &is, T &t, const char *delim = ", " ) 00665 { 00666 return is; 00667 } 00668 }; 00669 00670 #if defined HAVE_TUPLE || defined HAVE_TR1_TUPLE 00671 00674 template<typename T1> 00675 inline std::ostream& operator<<( std::ostream& os, const tuple<T1> & t) 00676 { 00677 typedef tuple<T1> TupleT; 00678 return tuple_writer<tuple_size<TupleT>::value>::put(os, t); 00679 } 00680 00681 template<typename T1, typename T2> 00682 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2> & t) 00683 { 00684 typedef tuple<T1,T2> TupleT; 00685 return tuple_writer<tuple_size<TupleT>::value>::put(os, t); 00686 } 00687 00688 template<typename T1, typename T2, typename T3> 00689 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3> & t) 00690 { 00691 typedef tuple<T1,T2,T3> TupleT; 00692 return tuple_writer<tuple_size<TupleT>::value>::put(os, t); 00693 } 00694 00695 template<typename T1, typename T2, typename T3, typename T4> 00696 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4> & t) 00697 { 00698 typedef tuple<T1,T2,T3,T4> TupleT; 00699 return tuple_writer<tuple_size<TupleT>::value>::put(os, t); 00700 } 00701 00702 template<typename T1, typename T2, typename T3, typename T4, typename T5> 00703 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5> & t) 00704 { 00705 typedef tuple<T1,T2,T3,T4,T5> 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> 00710 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6> & t) 00711 { 00712 typedef tuple<T1,T2,T3,T4,T5,T6> TupleT; 00713 return tuple_writer<tuple_size<TupleT>::value>::put(os, t); 00714 } 00715 00716 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> 00717 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7> & t) 00718 { 00719 typedef tuple<T1,T2,T3,T4,T5,T6,T7> TupleT; 00720 return tuple_writer<tuple_size<TupleT>::value>::put(os, t); 00721 } 00722 00723 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, 00724 typename T8> 00725 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8> & t) 00726 { 00727 typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8> TupleT; 00728 return tuple_writer<tuple_size<TupleT>::value>::put(os, t); 00729 } 00730 00731 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, 00732 typename T8, typename T9> 00733 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> & t) 00734 { 00735 typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> TupleT; 00736 return tuple_writer<tuple_size<TupleT>::value>::put(os, t); 00737 } 00738 00739 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, 00740 typename T8, typename T9, typename T10> 00741 inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> & t) 00742 { 00743 typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> TupleT; 00744 return tuple_writer<tuple_size<TupleT>::value>::put(os, t); 00745 } 00746 00750 template<typename T1> 00751 inline std::istream& operator>>( std::istream& is, tuple<T1> & t) 00752 { 00753 typedef tuple<T1> TupleT; 00754 return tuple_writer<tuple_size<TupleT>::value>::get(is, t); 00755 } 00756 00757 template<typename T1, typename T2> 00758 inline std::istream& operator>>( std::istream& is, tuple<T1,T2> & t) 00759 { 00760 typedef tuple<T1,T2> TupleT; 00761 return tuple_writer<tuple_size<TupleT>::value>::get(is, t); 00762 } 00763 00764 template<typename T1, typename T2, typename T3> 00765 inline std::istream& operator>>( std::istream& is, tuple<T1,T2,T3> & t) 00766 { 00767 typedef tuple<T1,T2,T3> TupleT; 00768 return tuple_writer<tuple_size<TupleT>::value>::get(is, t); 00769 } 00770 00771 template<typename T1, typename T2, typename T3, typename T4> 00772 inline std::istream& operator>>( std::istream& is, tuple<T1,T2,T3,T4> & t) 00773 { 00774 typedef tuple<T1,T2,T3,T4> TupleT; 00775 return tuple_writer<tuple_size<TupleT>::value>::get(is, t); 00776 } 00777 00778 template<typename T1, typename T2, typename T3, typename T4, typename T5> 00779 inline std::istream& operator>>( std::istream& is, tuple<T1,T2,T3,T4,T5> & t) 00780 { 00781 typedef tuple<T1,T2,T3,T4,T5> TupleT; 00782 return tuple_writer<tuple_size<TupleT>::value>::get(is, t); 00783 } 00784 00785 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> 00786 inline std::istream& operator>>( std::istream& is, tuple<T1,T2,T3,T4,T5,T6> & t) 00787 { 00788 typedef tuple<T1,T2,T3,T4,T5,T6> TupleT; 00789 return tuple_writer<tuple_size<TupleT>::value>::get(is, t); 00790 } 00791 00792 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> 00793 inline std::istream& operator>>( std::istream& is, tuple<T1,T2,T3,T4,T5,T6,T7> & t) 00794 { 00795 typedef tuple<T1,T2,T3,T4,T5,T6,T7> TupleT; 00796 return tuple_writer<tuple_size<TupleT>::value>::get(is, t); 00797 } 00798 00799 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, 00800 typename T8> 00801 inline std::istream& operator>>( std::istream& is, tuple<T1,T2,T3,T4,T5,T6,T7,T8> & t) 00802 { 00803 typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8> TupleT; 00804 return tuple_writer<tuple_size<TupleT>::value>::get(is, t); 00805 } 00806 00807 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, 00808 typename T8, typename T9> 00809 inline std::istream& operator>>( std::istream& is, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> & t) 00810 { 00811 typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> TupleT; 00812 return tuple_writer<tuple_size<TupleT>::value>::get(is, t); 00813 } 00814 00815 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, 00816 typename T8, typename T9, typename T10> 00817 inline std::istream& operator>>( std::istream& is, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> & t) 00818 { 00819 typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> TupleT; 00820 return tuple_writer<tuple_size<TupleT>::value>::get(is, t); 00821 } 00822 #else 00823 00828 template<typename T1, typename T2, typename U1, typename U2> 00829 inline bool operator==(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2) 00830 { 00831 return (tuple1.first()==tuple2.first() && tuple1.second()==tuple2.second()); 00832 } 00833 00839 template<typename T1, typename T2, typename U1, typename U2> 00840 inline bool operator!=(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2) 00841 { 00842 return (tuple1.first()!=tuple2.first() || tuple1.second()!=tuple2.second()); 00843 } 00844 00850 template<typename T1, typename T2, typename U1, typename U2> 00851 inline bool operator<(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2) 00852 { 00853 return tuple1.first() < tuple2.first() 00854 || (tuple1.first() == tuple2.first() && tuple1.second() < tuple2.second()); 00855 } 00856 00862 template<typename T1,typename U1> 00863 inline bool operator==(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2) 00864 { 00865 return (tuple1.first()==tuple2.first()); 00866 } 00867 00873 template<typename T1, typename U1> 00874 inline bool operator!=(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2) 00875 { 00876 dune_static_assert( (IsInteroperable<T1,U1>::value), 00877 "T1 and U1 have to be interoperable, i.e., either " 00878 "conversion from one to the other must exist." ); 00879 return (tuple1.first()!=tuple2.first()); 00880 } 00881 00887 template<typename T1, typename U1> 00888 inline bool operator<(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2) 00889 { 00890 return (tuple1.first()<tuple2.first()); 00891 } 00892 00900 template<typename T1,typename U1, typename U2> 00901 inline bool operator==(const Pair<T1,Nil>& tuple1, const Pair<U1,U2>& tuple2) 00902 { 00903 return false; 00904 } 00905 00912 template<typename T1, typename U1, typename U2> 00913 inline bool operator!=(const Pair<T1,Nil>& tuple1, const Pair<U1,U2>& tuple2) 00914 { 00915 return true; 00916 } 00917 00918 00925 template<typename T1, typename T2, typename U1> 00926 inline bool operator==(const Pair<T1,T2>& tuple1, const Pair<U1,Nil>& tuple2) 00927 { 00928 return false; 00929 } 00930 00937 template<typename T1, typename T2, typename U1> 00938 inline bool operator!=(const Pair<T1,T2>& tuple1, const Pair<U1,Nil>& tuple2) 00939 { 00940 return true; 00941 } 00942 00948 template<typename T1, typename T2> 00949 inline Pair<T1,T2> makePair(const T1& first, const T2& second) 00950 { 00951 return Pair<T1,T2>(first, second); 00952 } 00953 00957 template<typename T1, typename T2> 00958 inline std::ostream& operator<<(std::ostream& os, const Pair<T1,T2>& pair) 00959 { 00960 os<<pair.first()<<" "<<pair.second(); 00961 return os; 00962 } 00963 00964 template<typename T1> 00965 inline std::ostream& operator<<(std::ostream& os, const Pair<T1,Nil>& pair) 00966 { 00967 os<<pair.first(); 00968 return os; 00969 } 00970 00974 template<typename T1, typename T2> 00975 inline std::istream& operator>>(std::istream& is, Pair<T1,T2>& pair) 00976 { 00977 return is >> pair.first() >> pair.second(); 00978 } 00979 00980 template<typename T1> 00981 inline std::istream& operator>>(std::istream& is, Pair<T1,Nil>& pair) 00982 { 00983 return is >> pair.first(); 00984 } 00985 00986 template<class T1> 00987 inline tuple<T1&> tie(T1& t1) { 00988 return tuple<T1&> (t1); 00989 } 00990 00991 template<class T1, class T2> 00992 inline tuple<T1&, T2&> tie(T1& t1, T2& t2) { 00993 return tuple<T1&, T2&> (t1, t2); 00994 } 00995 00996 template<class T1, class T2, class T3> 00997 inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) { 00998 return tuple<T1&, T2&, T3&> (t1, t2, t3); 00999 } 01000 01001 template<class T1, class T2, class T3, class T4> 01002 inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) { 01003 return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4); 01004 } 01005 01006 template<class T1, class T2, class T3, class T4, class T5> 01007 inline tuple<T1&, T2&, T3&, T4&, T5&> 01008 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) { 01009 return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5); 01010 } 01011 01012 template<class T1, class T2, class T3, class T4, class T5, class T6> 01013 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&> 01014 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) { 01015 return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6); 01016 } 01017 01018 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7> 01019 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> 01020 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) { 01021 return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7); 01022 } 01023 01024 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, 01025 class T8> 01026 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&> 01027 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) { 01028 return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&> 01029 (t1, t2, t3, t4, t5, t6, t7, t8); 01030 } 01031 01032 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, 01033 class T8, class T9> 01034 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&> 01035 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9) { 01036 return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&> 01037 (t1, t2, t3, t4, t5, t6, t7, t8, t9); 01038 } 01039 01040 template<class T1> 01041 inline tuple<T1> make_tuple(const T1& t1) { 01042 return tuple<T1> (t1); 01043 } 01044 01045 template<class T1, class T2> 01046 inline tuple<T1, T2> make_tuple(const T1& t1, const T2& t2) { 01047 return tuple<T1, T2> (t1, t2); 01048 } 01049 01050 template<class T1, class T2, class T3> 01051 inline tuple<T1, T2, T3> make_tuple(const T1& t1, const T2& t2, const T3& t3) { 01052 return tuple<T1, T2, T3> (t1, t2, t3); 01053 } 01054 01055 template<class T1, class T2, class T3, class T4> 01056 inline tuple<T1, T2, T3, T4> make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4) { 01057 return tuple<T1, T2, T3, T4> (t1, t2, t3, t4); 01058 } 01059 01060 template<class T1, class T2, class T3, class T4, class T5> 01061 inline tuple<T1, T2, T3, T4, T5> 01062 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) { 01063 return tuple<T1, T2, T3, T4, T5> (t1, t2, t3, t4, t5); 01064 } 01065 01066 template<class T1, class T2, class T3, class T4, class T5, class T6> 01067 inline tuple<T1, T2, T3, T4, T5, T6> 01068 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) { 01069 return tuple<T1, T2, T3, T4, T5, T6> (t1, t2, t3, t4, t5, t6); 01070 } 01071 01072 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7> 01073 inline tuple<T1, T2, T3, T4, T5, T6, T7> 01074 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, 01075 const T7& t7) { 01076 return tuple<T1, T2, T3, T4, T5, T6, T7> (t1, t2, t3, t4, t5, t6, t7); 01077 } 01078 01079 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, 01080 class T8> 01081 inline tuple<T1, T2, T3, T4, T5, T6, T7, T8> 01082 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, 01083 const T7& t7, const T8& t8) { 01084 return tuple<T1, T2, T3, T4, T5, T6, T7, T8> 01085 (t1, t2, t3, t4, t5, t6, t7, t8); 01086 } 01087 01088 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, 01089 class T8, class T9> 01090 inline tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> 01091 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, 01092 const T7& t7, const T8& t8, const T9& t9) { 01093 return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> 01094 (t1, t2, t3, t4, t5, t6, t7, t8, t9); 01095 } 01096 01097 template<typename T1, typename TT> 01098 template<typename T2, typename T3, typename T4, typename T5, 01099 typename T6, typename T7, typename T8, typename T9> 01100 inline Pair<T1,TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first, 01101 T2& t2, T3& t3, T4& t4, T5& t5, 01102 T6& t6, T7& t7, T8& t8, T9& t9) 01103 : first_(first), second_(t2,t3,t4,t5,t6,t7,t8,t9, nullType()) 01104 {} 01105 01106 template <typename T1, typename TT> 01107 inline Pair<T1, TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first, TT& second) 01108 : first_(first), second_(second) 01109 {} 01110 01111 template<typename T1, typename T2> 01112 inline Pair<T1,T2>::Pair() 01113 : first_(), second_() 01114 {} 01115 01116 template<typename T1, typename T2> 01117 template<typename U1, typename U2> 01118 inline Pair<T1,T2>::Pair(const Pair<U1,U2>& other) 01119 : first_(other.first_), second_(other.second_) 01120 {} 01121 01122 template<typename T1, typename T2> 01123 template<typename U1, typename U2> 01124 inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair<U1,U2>& other) 01125 { 01126 first_=other.first_; 01127 second_=other.second_; 01128 return *this; 01129 } 01130 01131 template<typename T1, typename T2> 01132 inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair& other) 01133 { 01134 first_=other.first_; 01135 second_=other.second_; 01136 return *this; 01137 } 01138 01139 template<typename T1, typename T2> 01140 inline typename TupleAccessTraits<T1>::NonConstType 01141 Pair<T1,T2>::first() 01142 { 01143 return first_; 01144 } 01145 01146 template<typename T1, typename T2> 01147 inline typename TupleAccessTraits<T1>::ConstType 01148 Pair<T1,T2>::first() const 01149 { 01150 return first_; 01151 } 01152 01153 01154 template<typename T1, typename T2> 01155 inline typename TupleAccessTraits<T2>::NonConstType 01156 Pair<T1,T2>::second() 01157 { 01158 return second_; 01159 } 01160 01161 template<typename T1, typename T2> 01162 inline typename TupleAccessTraits<T2>::ConstType 01163 Pair<T1,T2>::second() const 01164 { 01165 return second_; 01166 } 01167 01168 template<typename T1> 01169 inline Pair<T1,Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first, 01170 const Nil&, const Nil&, const Nil&, const Nil&, 01171 const Nil&, const Nil&, const Nil&, const Nil&) 01172 : first_(first) 01173 {} 01174 01175 template <typename T1> 01176 inline Pair<T1, Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first, 01177 const Nil&) 01178 : first_(first) 01179 {} 01180 01181 template<typename T1> 01182 inline Pair<T1,Nil>::Pair() 01183 : first_() 01184 {} 01185 01186 template<typename T1> 01187 template<typename T2> 01188 inline Pair<T1,Nil>::Pair(const Pair<T2,Nil>& other) 01189 : first_(other.first_) 01190 {} 01191 01192 template<typename T1> 01193 template<typename T2> 01194 Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair<T2,Nil>& other) 01195 { 01196 first_ = other.first_; 01197 return *this; 01198 } 01199 01200 01201 template<typename T1> 01202 Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair& other) 01203 { 01204 first_ = other.first_; 01205 return *this; 01206 } 01207 01208 template<typename T1> 01209 inline typename TupleAccessTraits<T1>::NonConstType 01210 Pair<T1,Nil>::first() 01211 { 01212 return first_; 01213 } 01214 01215 template<typename T1> 01216 inline typename TupleAccessTraits<T1>::ConstType 01217 Pair<T1,Nil>::first() const 01218 { 01219 return first_; 01220 } 01221 01223 #endif 01224 } 01225 #endif