tuples.hh

Go to the documentation of this file.
00001 // $Id: tuples.hh 5356 2008-11-11 21:31:43Z mblatt $
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 //     enum{
00095 //     /**
00096 //      * @brief The number of values we hold.
00097 //      */
00098 //       values = 2;
00099 //     };
00100     
00107     template<typename T2, typename T3, typename T4, typename T5,
00108              typename T6, typename T7, typename T8, typename T9>
00109     Pair(typename TupleAccessTraits<T1>::ParameterType t1, T2& t2, T3& t3, T4& t4, T5& t5, 
00110          T6& t6, T7& t7, T8& t8, T9& t9);
00111 
00118     Pair(typename TupleAccessTraits<Type1>::ParameterType t1, TT& t2);
00119 
00120     Pair();
00121     
00126     template<typename U1, typename U2>
00127     Pair(const Pair<U1,U2>& other);
00128     
00133     template<typename U1, typename U2>
00134     Pair& operator=(const Pair<U1,U2>& other);
00135     
00136     Pair& operator=(const Pair& other);
00137     
00142     typename TupleAccessTraits<Type1>::NonConstType first();
00143     
00148     typename TupleAccessTraits<Type1>::ConstType 
00149     first() const;
00150 
00155     typename TupleAccessTraits<Type2>::NonConstType
00156     second();
00157     
00162     typename TupleAccessTraits<Type2>::ConstType 
00163     second() const;
00164 
00166     Type1 first_;
00168     Type2 second_;
00169     
00170   };
00171 
00176   template<typename T1>
00177   struct Pair<T1,Nil>
00178   {
00182     typedef T1 Type1;
00183 
00189     typedef Nil Type2;
00190 
00196     Pair(typename TupleAccessTraits<T1>::ParameterType first, const Nil&, const Nil&, const Nil&, const Nil&,
00197          const Nil&, const Nil&, const Nil&, const Nil&);
00198     
00204     Pair(typename TupleAccessTraits<T1>::ParameterType first, 
00205          const Nil&);
00206 
00207     Pair();
00208     
00212     template<typename T2>
00213     Pair(const Pair<T2,Nil>& other);
00214 
00218     template<typename T2>
00219     Pair& operator=(const Pair<T2,Nil>& other);
00220     
00224     Pair& operator=(const Pair& other);
00225 
00230     typename TupleAccessTraits<Type1>::NonConstType
00231     first();
00232     
00237     typename TupleAccessTraits<Type1>::ConstType 
00238     first() const;
00239 
00241     Type1 first_;
00242   };
00243   
00244     
00248   template<typename T1, typename T2, typename T3, typename T4, typename T5,
00249            typename T6, typename T7, typename T8, typename T9>
00250   struct TupleToPairs
00251   {
00252     typedef Pair<T1, typename TupleToPairs<T2,T3,T4,T5,T6,T7,T8,T9,Nil>::Type > Type;
00253   };
00254 
00258   template<typename T1>
00259   struct TupleToPairs<T1,Nil,Nil,Nil,Nil,Nil,Nil,Nil,Nil>
00260   {
00261     typedef Pair<T1,Nil> Type;
00262   };
00263   
00281   template<typename T1, typename T2 = Nil, typename T3 = Nil, 
00282            typename T4 = Nil, typename T5 = Nil,typename T6 = Nil, 
00283            typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
00284   class tuple : public TupleToPairs<T1,T2,T3,T4,T5,T6,T7,T8,T9>::Type
00285   {
00286   public:
00288     typedef typename TupleToPairs<T1,T2,T3,T4,T5,T6,T7,T8,T9>::Type FirstPair;
00289 
00290     tuple()
00291     {}
00292 
00293     tuple(typename TupleAccessTraits<T1>::ParameterType t1)
00294       : FirstPair(t1, nullType(), nullType(), nullType(), 
00295                   nullType(), nullType(), nullType(), nullType(), 
00296                   nullType())
00297     {}
00298 
00299     tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00300           typename TupleAccessTraits<T2>::ParameterType t2)
00301       : FirstPair(t1, t2, nullType(), nullType(), 
00302                   nullType(), nullType(), nullType(), nullType(), 
00303                   nullType())
00304     {}
00305 
00306     tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00307           typename TupleAccessTraits<T2>::ParameterType t2,
00308           typename TupleAccessTraits<T3>::ParameterType t3)
00309       : FirstPair(t1, t2, t3, nullType(), 
00310                   nullType(), nullType(), nullType(), nullType(), 
00311                   nullType())
00312     {}
00313 
00314     tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00315           typename TupleAccessTraits<T2>::ParameterType t2,
00316           typename TupleAccessTraits<T3>::ParameterType t3,
00317           typename TupleAccessTraits<T4>::ParameterType t4)
00318       : FirstPair(t1, t2, t3, t4, 
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           typename TupleAccessTraits<T5>::ParameterType t5)
00328       : FirstPair(t1, t2, t3, t4, 
00329                   t5, nullType(), nullType(), nullType(), 
00330                   nullType())
00331     {}
00332 
00333     tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00334           typename TupleAccessTraits<T2>::ParameterType t2,
00335           typename TupleAccessTraits<T3>::ParameterType t3,
00336           typename TupleAccessTraits<T4>::ParameterType t4,
00337           typename TupleAccessTraits<T5>::ParameterType t5,
00338           typename TupleAccessTraits<T6>::ParameterType t6)
00339       : FirstPair(t1, t2, t3, t4, 
00340                   t5, t6, nullType(), nullType(), 
00341                   nullType())
00342     {}
00343 
00344     tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00345           typename TupleAccessTraits<T2>::ParameterType t2,
00346           typename TupleAccessTraits<T3>::ParameterType t3,
00347           typename TupleAccessTraits<T4>::ParameterType t4,
00348           typename TupleAccessTraits<T5>::ParameterType t5,
00349           typename TupleAccessTraits<T6>::ParameterType t6,
00350           typename TupleAccessTraits<T7>::ParameterType t7)
00351       : FirstPair(t1, t2, t3, t4, 
00352                   t5, t6, t7, nullType(), 
00353                   nullType())
00354     {}
00355 
00356     tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00357           typename TupleAccessTraits<T2>::ParameterType t2,
00358           typename TupleAccessTraits<T3>::ParameterType t3,
00359           typename TupleAccessTraits<T4>::ParameterType t4,
00360           typename TupleAccessTraits<T5>::ParameterType t5,
00361           typename TupleAccessTraits<T6>::ParameterType t6,
00362           typename TupleAccessTraits<T7>::ParameterType t7,
00363           typename TupleAccessTraits<T8>::ParameterType t8)
00364       : FirstPair(t1, t2, t3, t4,
00365                   t5, t6, t7, t8, 
00366                   nullType())
00367     {}
00368 
00369     tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00370           typename TupleAccessTraits<T2>::ParameterType t2,
00371           typename TupleAccessTraits<T3>::ParameterType t3,
00372           typename TupleAccessTraits<T4>::ParameterType t4,
00373           typename TupleAccessTraits<T5>::ParameterType t5,
00374           typename TupleAccessTraits<T6>::ParameterType t6,
00375           typename TupleAccessTraits<T7>::ParameterType t7,
00376           typename TupleAccessTraits<T8>::ParameterType t8,
00377           typename TupleAccessTraits<T9>::ParameterType t9)
00378       : FirstPair(t1, t2, t3, t4, t5, t6, t7, t8, t9)
00379     {}
00380 
00381     template<class U1, class U2>
00382     tuple& operator=(const Pair<U1,U2>& other)
00383     {
00384       FirstPair::operator=(other);
00385       return *this;
00386     }
00387   };
00388 
00389 #endif
00390 
00391   // be backwards compatible
00392 #define Tuple tuple
00393 
00394 #ifdef HAVE_TUPLE
00395   using std::tuple_element;
00396 #elif defined HAVE_TR1_TUPLE
00397   using std::tr1::tuple_element;
00398 #else
00399 
00402   template<int N, class Tuple>
00403   struct tuple_element
00404   {
00408     typedef typename tuple_element<N,typename Tuple::FirstPair>::type type;
00409     typedef typename tuple_element<N,typename Tuple::FirstPair>::type Type;
00410   };
00411   
00412   template<int N, typename T1, typename T2>
00413   struct tuple_element<N,Pair<T1,T2> >
00414   {
00418     typedef typename tuple_element<N-1,T2>::Type type;
00419     typedef typename tuple_element<N-1,T2>::Type Type;
00420   };
00421   
00425   template<typename T1, typename T2>
00426   struct tuple_element<0, Pair<T1,T2> >
00427   {
00431     typedef T1 type;
00432     typedef T1 Type;
00433   };
00434   
00435 #endif
00436 
00437 template< int N, class T >
00438 struct ElementType
00439 {
00440   typedef typename tuple_element< N, T > :: type Type DUNE_DEPRECATED;
00441 };
00442 
00443 #if defined HAVE_TUPLE || defined HAVE_TR1_TUPLE
00444 #ifdef HAVE_TUPLE
00445   #define TUPLE_NS std
00446   using std::get;
00447 #elif defined HAVE_TR1_TUPLE
00448   #define TUPLE_NS std::tr1
00449   using std::tr1::get;
00450 #endif
00451 
00452   // for backwards compatibility
00453   template<int i>
00454   struct Element{
00455     template<typename T1>
00456     static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::NonConstType get(T1& t)
00457     {
00458       return TUPLE_NS::get<i>(t);
00459     }
00460 
00461     template<typename T1>
00462     static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::ConstType get(const T1& t)
00463     {
00464       return TUPLE_NS::get<i>(t);
00465     }
00466   };
00467   #undef TUPLE_NS
00468   
00469 #else
00470 
00473   template<int N>
00474   struct Element
00475   {
00481     template<typename T1, typename T2>
00482     static typename TupleAccessTraits<
00483       typename tuple_element<N,Pair<T1,T2> >::type
00484     >::NonConstType
00485     get(Pair<T1,T2>& tuple)
00486     {
00487       return Element<N-1>::get(tuple.second());
00488     }
00489     
00495     template<typename T1, typename T2>
00496     static typename TupleAccessTraits<
00497       typename tuple_element<N,Pair<T1,T2> >::type
00498     >::ConstType
00499     get(const Pair<T1,T2>& tuple)
00500     {
00501       return Element<N-1>::get(tuple.second());
00502     }
00503   };
00504   
00508   template<>
00509   struct Element<0>
00510   {
00516     template<typename T1, typename T2>
00517     static typename TupleAccessTraits<T1>::NonConstType get(Pair<T1,T2>& tuple)
00518     {
00519       return tuple.first();
00520     }
00521     
00527     template<typename T1, typename T2>
00528     static typename TupleAccessTraits<T1>::ConstType get(const Pair<T1,T2>& tuple)
00529     {
00530       return tuple.first();
00531     }
00532   };
00533 
00534   template<int i, typename T1, typename T2, typename T3, typename T4,
00535            typename T5, typename T6, typename T7, typename T8, typename T9>
00536   typename TupleAccessTraits<typename tuple_element<i, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::type>
00537   ::NonConstType 
00538   get(tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>& t)
00539   {
00540     return Element<i>::get(t);
00541   }
00542 
00543   template<int i, typename T1, typename T2, typename T3, typename T4,
00544            typename T5, typename T6, typename T7, typename T8, typename T9>
00545   typename TupleAccessTraits<typename tuple_element<i, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::type>
00546   ::ConstType 
00547   get(const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>& t)
00548   {
00549     return Element<i>::get(t);
00550   }
00551 
00552 #endif  
00553 
00554 #ifdef HAVE_TUPLE
00555   using std::tuple_size;
00556 #elif defined HAVE_TR1_TUPLE
00557   using std::tr1::tuple_size;
00558 #else
00559 
00563   template<class T>
00564   struct tuple_size
00565   {
00566     enum{ 
00567       // @brief The number of Elements in the tuple.
00568       value=tuple_size<typename T::FirstPair>::value
00569         };
00570     
00571     
00572   };
00573   
00574   template<typename T1, typename T2>
00575   struct tuple_size<Pair<T1,T2> >
00576   {
00577     enum{ value=1+tuple_size<T2>::value};
00578   };
00579   
00580   
00581   template<typename T1>
00582   struct tuple_size<Pair<T1,Nil> >
00583   {
00584     enum{ value=1};
00585   };
00586 
00587   template<>
00588   struct tuple_size<Pair<Nil,Nil> >
00589   {
00590     enum{ value=0};
00591   };
00592 #endif
00593   template<typename T>
00594   struct Size : public tuple_size<T>
00595   {
00596   };
00597   
00598 
00599 #ifdef HAVE_TUPLE    
00600   using std::tie;
00601   using std::make_tuple;
00602 #elif defined HAVE_TR1_TUPLE    
00603   using std::tr1::tie;
00604   using std::tr1::make_tuple;
00605 #endif
00606 
00607 #if defined HAVE_TUPLE || defined HAVE_TR1_TUPLE
00608   template<int i>
00609   struct tuple_writer
00610   {
00611     template<class T>
00612     static std::ostream& put(std::ostream& os, const T& t)
00613     {
00614       return tuple_writer<i-1>::put(os,t)<<", "<<get<i-1>(t);
00615     }
00616   };
00617   
00618   template<>
00619   struct tuple_writer<0>
00620   {
00621     template<class T>
00622     static std::ostream& put(std::ostream& os, const T& t)
00623     {
00624       return os;
00625     }
00626   };
00627 
00631   template<typename T1>
00632   inline std::ostream& operator<<( std::ostream& os, const tuple<T1> & t)
00633   {
00634     typedef tuple<T1> TupleT;
00635     return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00636   }
00637   
00638   template<typename T1, typename T2>
00639   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2> & t)
00640   {
00641     typedef tuple<T1,T2> TupleT;
00642     return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00643   }
00644   
00645   template<typename T1, typename T2, typename T3>
00646   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3> & t)
00647   {
00648     typedef tuple<T1,T2,T3> TupleT;
00649     return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00650   }
00651   
00652   template<typename T1, typename T2, typename T3, typename T4>
00653   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4> & t)
00654   {
00655     typedef tuple<T1,T2,T3,T4> TupleT;
00656     return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00657   }
00658   
00659   template<typename T1, typename T2, typename T3, typename T4, typename T5>
00660   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5> & t)
00661   {
00662     typedef tuple<T1,T2,T3,T4,T5> TupleT;
00663     return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00664   }
00665   
00666   template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
00667   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6> & t)
00668   {
00669     typedef tuple<T1,T2,T3,T4,T5,T6> TupleT;
00670     return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00671   }
00672   
00673   template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
00674   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7> & t)
00675   {
00676     typedef tuple<T1,T2,T3,T4,T5,T6,T7> TupleT;
00677     return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00678   }
00679   
00680   template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
00681            typename T8>
00682   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8> & t)
00683   {
00684     typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8> TupleT;
00685     return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00686   }
00687   
00688   template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
00689            typename T8, typename T9>
00690   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> & t)
00691   {
00692     typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> TupleT;
00693     return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00694   }
00695   
00696   template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
00697            typename T8, typename T9, typename T10>
00698   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> & t)
00699   {
00700     typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> TupleT;
00701     return tuple_writer<tuple_size<TupleT>::value>::put(os, t);
00702   }
00703 
00704 #else
00705 
00710   template<typename T1, typename T2, typename U1, typename U2>
00711   inline bool operator==(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00712   {
00713     return (tuple1.first()==tuple2.first() && tuple1.second()==tuple2.second());
00714   }
00715   
00721   template<typename T1, typename T2, typename U1, typename U2>
00722   inline bool operator!=(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00723   {
00724     return (tuple1.first()!=tuple2.first() || tuple1.second()!=tuple2.second());
00725   }
00726 
00732   template<typename T1, typename T2, typename U1, typename U2>
00733   inline bool operator<(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00734   {
00735     return tuple1.first() < tuple2.first()
00736       || (tuple1.first() == tuple2.first() && tuple1.second() < tuple2.second());
00737   }
00738 
00744   template<typename T1,typename U1>
00745   inline bool operator==(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00746   {
00747     return (tuple1.first()==tuple2.first());
00748   }
00749   
00755   template<typename T1, typename U1>
00756   inline bool operator!=(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00757   {
00758     dune_static_assert( (IsInteroperable<T1,U1>::value),
00759                         "T1 and U1 have to be interoperable, i.e., either "
00760                         "conversion from one to the other must exist." );
00761     return (tuple1.first()!=tuple2.first());
00762   }
00763 
00769   template<typename T1, typename U1>
00770   inline bool operator<(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00771   {
00772     return (tuple1.first()<tuple2.first());
00773   }
00774 
00782   template<typename T1,typename U1, typename U2>
00783   inline bool operator==(const Pair<T1,Nil>& tuple1, const Pair<U1,U2>& tuple2)
00784   {
00785     return false;
00786   }
00787   
00794   template<typename T1, typename U1, typename U2>
00795   inline bool operator!=(const Pair<T1,Nil>& tuple1, const Pair<U1,U2>& tuple2)
00796   {
00797     return true;
00798   }
00799 
00800 
00807   template<typename T1, typename T2, typename U1>
00808   inline bool operator==(const Pair<T1,T2>& tuple1, const Pair<U1,Nil>& tuple2)
00809   {
00810     return false;
00811   }
00812   
00819   template<typename T1, typename T2, typename U1>
00820   inline bool operator!=(const Pair<T1,T2>& tuple1, const Pair<U1,Nil>& tuple2)
00821   {
00822     return true;
00823   }
00824 
00830   template<typename T1, typename T2>
00831   inline Pair<T1,T2> makePair(const T1& first, const T2& second)
00832   {
00833     return Pair<T1,T2>(first, second);
00834   }
00835 
00839   template<typename T1, typename T2>
00840   inline std::ostream& operator<<(std::ostream& os, const Pair<T1,T2>& pair)
00841   {
00842     os<<pair.first()<<" "<<pair.second();
00843     return os;
00844   }
00845 
00846   template<typename T1>
00847   inline std::ostream& operator<<(std::ostream& os, const Pair<T1,Nil>& pair)
00848   {
00849     os<<pair.first();
00850     return os;
00851   }
00852 
00853   template<class T1>
00854   inline tuple<T1&> tie(T1& t1) {
00855     return tuple<T1&> (t1);
00856   }
00857 
00858   template<class T1, class T2>
00859   inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {
00860     return tuple<T1&, T2&> (t1, t2);
00861   }
00862 
00863   template<class T1, class T2, class T3>
00864   inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {
00865     return tuple<T1&, T2&, T3&> (t1, t2, t3);
00866   }
00867 
00868   template<class T1, class T2, class T3, class T4>
00869   inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
00870     return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);
00871   }
00872 
00873   template<class T1, class T2, class T3, class T4, class T5>
00874   inline tuple<T1&, T2&, T3&, T4&, T5&>
00875   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
00876     return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
00877   }
00878 
00879   template<class T1, class T2, class T3, class T4, class T5, class T6>
00880   inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
00881   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
00882     return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
00883   }
00884 
00885   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
00886   inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
00887   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
00888     return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
00889   }
00890 
00891   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00892            class T8>
00893   inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
00894   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
00895     return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
00896       (t1, t2, t3, t4, t5, t6, t7, t8);
00897   }
00898 
00899   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00900            class T8, class T9>
00901   inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
00902   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9) {
00903     return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
00904       (t1, t2, t3, t4, t5, t6, t7, t8, t9);
00905   }
00906 
00907   template<class T1>
00908   inline tuple<T1> make_tuple(const T1& t1) {
00909     return tuple<T1> (t1);
00910   }
00911 
00912   template<class T1, class T2>
00913   inline tuple<T1, T2> make_tuple(const T1& t1, const T2& t2) {
00914     return tuple<T1, T2> (t1, t2);
00915   }
00916 
00917   template<class T1, class T2, class T3>
00918   inline tuple<T1, T2, T3> make_tuple(const T1& t1, const T2& t2, const T3& t3) {
00919     return tuple<T1, T2, T3> (t1, t2, t3);
00920   }
00921 
00922   template<class T1, class T2, class T3, class T4>
00923   inline tuple<T1, T2, T3, T4> make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
00924     return tuple<T1, T2, T3, T4> (t1, t2, t3, t4);
00925   }
00926 
00927   template<class T1, class T2, class T3, class T4, class T5>
00928   inline tuple<T1, T2, T3, T4, T5>
00929   make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) {
00930     return tuple<T1, T2, T3, T4, T5> (t1, t2, t3, t4, t5);
00931   }
00932 
00933   template<class T1, class T2, class T3, class T4, class T5, class T6>
00934   inline tuple<T1, T2, T3, T4, T5, T6>
00935   make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) {
00936     return tuple<T1, T2, T3, T4, T5, T6> (t1, t2, t3, t4, t5, t6);
00937   }
00938 
00939   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
00940   inline tuple<T1, T2, T3, T4, T5, T6, T7>
00941   make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00942              const T7& t7) {
00943     return tuple<T1, T2, T3, T4, T5, T6, T7> (t1, t2, t3, t4, t5, t6, t7);
00944   }
00945 
00946   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00947            class T8>
00948   inline tuple<T1, T2, T3, T4, T5, T6, T7, T8>
00949   make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00950              const T7& t7, const T8& t8) {
00951     return tuple<T1, T2, T3, T4, T5, T6, T7, T8>
00952       (t1, t2, t3, t4, t5, t6, t7, t8);
00953   }
00954 
00955   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00956            class T8, class T9>
00957   inline tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
00958   make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00959              const  T7& t7, const T8& t8, const T9& t9) {
00960     return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
00961       (t1, t2, t3, t4, t5, t6, t7, t8, t9);
00962   }
00963 
00964   template<typename T1, typename TT>
00965   template<typename T2, typename T3, typename T4, typename T5,
00966            typename T6, typename T7, typename T8, typename T9>
00967   inline Pair<T1,TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first, 
00968                            T2& t2, T3& t3, T4& t4, T5& t5, 
00969                            T6& t6, T7& t7, T8& t8, T9& t9)
00970     : first_(first), second_(t2,t3,t4,t5,t6,t7,t8,t9, nullType())
00971   {}
00972 
00973   template <typename T1, typename TT>
00974   inline Pair<T1, TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first, TT& second) 
00975     : first_(first), second_(second)
00976   {}
00977   
00978   template<typename T1, typename T2>
00979   inline Pair<T1,T2>::Pair()
00980     : first_(), second_()
00981   {}
00982   
00983   template<typename T1, typename T2>
00984   template<typename U1, typename U2>
00985   inline Pair<T1,T2>::Pair(const Pair<U1,U2>& other)
00986     : first_(other.first_), second_(other.second_)
00987   {}
00988   
00989   template<typename T1, typename T2>
00990   template<typename U1, typename U2>
00991   inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair<U1,U2>& other)
00992   {
00993     first_=other.first_;
00994     second_=other.second_;
00995     return *this;
00996   }
00997 
00998   template<typename T1, typename T2>
00999   inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair& other)
01000   {
01001     first_=other.first_;
01002     second_=other.second_;
01003     return *this;
01004   }
01005 
01006   template<typename T1, typename T2>
01007   inline typename TupleAccessTraits<T1>::NonConstType 
01008   Pair<T1,T2>::first()
01009   {
01010     return first_;
01011   }
01012   
01013   template<typename T1, typename T2>
01014   inline typename TupleAccessTraits<T1>::ConstType 
01015   Pair<T1,T2>::first() const
01016   {
01017     return first_;
01018   }
01019  
01020   
01021   template<typename T1, typename T2>
01022   inline typename TupleAccessTraits<T2>::NonConstType
01023   Pair<T1,T2>::second()
01024   {
01025     return second_;
01026   }
01027   
01028   template<typename T1, typename T2>
01029   inline typename TupleAccessTraits<T2>::ConstType
01030   Pair<T1,T2>::second() const
01031   {
01032     return second_;
01033   }
01034 
01035   template<typename T1>
01036   inline Pair<T1,Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
01037                             const Nil&, const Nil&, const Nil&, const Nil&,
01038                             const Nil&, const Nil&, const Nil&, const Nil&)
01039     : first_(first)
01040   {}
01041 
01042   template <typename T1>
01043   inline Pair<T1, Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
01044                              const Nil&)
01045     : first_(first)
01046   {}
01047 
01048   template<typename T1>
01049   inline Pair<T1,Nil>::Pair()
01050     : first_()
01051   {}
01052   
01053   template<typename T1>
01054   template<typename T2>
01055   inline Pair<T1,Nil>::Pair(const Pair<T2,Nil>& other)
01056     : first_(other.first_)
01057   {}
01058 
01059   template<typename T1>
01060   template<typename T2>
01061   Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair<T2,Nil>& other)
01062   {
01063     first_ = other.first_;
01064     return *this;
01065   }
01066 
01067   
01068   template<typename T1>
01069   Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair& other)
01070   {
01071     first_ = other.first_;
01072     return *this;
01073   }
01074 
01075   template<typename T1>
01076   inline typename TupleAccessTraits<T1>::NonConstType 
01077   Pair<T1,Nil>::first()
01078   {
01079     return first_;
01080   }
01081   
01082   template<typename T1>
01083   inline typename TupleAccessTraits<T1>::ConstType 
01084   Pair<T1,Nil>::first() const
01085   {
01086     return first_;
01087   }
01088  
01089 #endif
01090 }
01091 #endif

Generated on Tue Jul 28 22:27:50 2009 for dune-common by  doxygen 1.5.6