tuples.hh

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