tuples.hh

Go to the documentation of this file.
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

Generated on Fri Apr 29 2011 with Doxygen (ver 1.7.1) [doxygen-log,error-log].