tuples.hh

Go to the documentation of this file.
00001 // $Id: tuples.hh 5331 2008-10-28 12:28:48Z robertk $
00002 #ifndef DUNE_TUPLES_HH
00003 #define DUNE_TUPLES_HH
00004 
00005 #include<ostream>
00006 #include"typetraits.hh"
00007 #include"static_assert.hh"
00008 #include"helpertemplates.hh"
00009 
00010 #ifdef HAVE_TUPLE
00011 #include <tuple>
00012 #elif defined HAVE_TR1_TUPLE
00013 #include <tr1/tuple>
00014 #endif
00015 
00016 namespace Dune{
00035   template<class T>
00036   struct TupleAccessTraits
00037   {
00038     typedef typename ConstantVolatileTraits<T>::ConstType& ConstType;
00039     typedef T& NonConstType;
00040     typedef const typename ConstantVolatileTraits<T>::UnqualifiedType& ParameterType;
00041   };
00042   
00043   template<class T>
00044   struct TupleAccessTraits<T*>
00045   {
00046     typedef typename ConstantVolatileTraits<T>::ConstType* ConstType;
00047     typedef T* NonConstType;
00048     typedef T* ParameterType;
00049   };
00050 
00051   template<class T>
00052   struct TupleAccessTraits<T&>
00053   {
00054     typedef typename ConstantVolatileTraits<T>::ConstType& ConstType;
00055     typedef T& NonConstType;
00056     typedef T& ParameterType;
00057   };
00058 
00059 #ifdef HAVE_TUPLE
00060   using std::tuple;
00061 #elif defined HAVE_TR1_TUPLE
00062   using std::tr1::tuple;
00063 #else
00064 
00067   struct Nil
00068   {};
00069 
00070   namespace
00071   {
00072     inline const Nil nullType()
00073     {
00074       return Nil();
00075     }
00076   }
00077 
00083   template<typename T1, typename TT>
00084   struct Pair
00085   {
00089     typedef T1 Type1;
00090     
00094     typedef TT Type2;
00095 //     enum{
00096 //     /**
00097 //      * @brief The number of values we hold.
00098 //      */
00099 //       values = 2;
00100 //     };
00101     
00108     template<typename T2, typename T3, typename T4, typename T5,
00109              typename T6, typename T7, typename T8, typename T9>
00110     Pair(typename TupleAccessTraits<T1>::ParameterType t1, T2& t2, T3& t3, T4& t4, T5& t5, 
00111          T6& t6, T7& t7, T8& t8, T9& t9);
00112 
00119     Pair(typename TupleAccessTraits<Type1>::ParameterType t1, TT& t2);
00120 
00121     Pair();
00122     
00127     template<typename U1, typename U2>
00128     Pair(const Pair<U1,U2>& other);
00129     
00134     template<typename U1, typename U2>
00135     Pair& operator=(const Pair<U1,U2>& other);
00136     
00137     Pair& operator=(const Pair& other);
00138     
00143     typename TupleAccessTraits<Type1>::NonConstType first();
00144     
00149     typename TupleAccessTraits<Type1>::ConstType 
00150     first() const;
00151 
00156     typename TupleAccessTraits<Type2>::NonConstType
00157     second();
00158     
00163     typename TupleAccessTraits<Type2>::ConstType 
00164     second() const;
00165 
00167     Type1 first_;
00169     Type2 second_;
00170     
00171   };
00172 
00177   template<typename T1>
00178   struct Pair<T1,Nil>
00179   {
00183     typedef T1 Type1;
00184 
00190     typedef Nil Type2;
00191 
00197     Pair(typename TupleAccessTraits<T1>::ParameterType first, const Nil&, const Nil&, const Nil&, const Nil&,
00198          const Nil&, const Nil&, const Nil&, const Nil&);
00199     
00205     Pair(typename TupleAccessTraits<T1>::ParameterType first, 
00206          const Nil&);
00207 
00208     Pair();
00209     
00213     template<typename T2>
00214     Pair(const Pair<T2,Nil>& other);
00215 
00219     template<typename T2>
00220     Pair& operator=(const Pair<T2,Nil>& other);
00221     
00225     Pair& operator=(const Pair& other);
00226 
00231     typename TupleAccessTraits<Type1>::NonConstType
00232     first();
00233     
00238     typename TupleAccessTraits<Type1>::ConstType 
00239     first() const;
00240 
00242     Type1 first_;
00243   };
00244   
00245     
00249   template<typename T1, typename T2, typename T3, typename T4, typename T5,
00250            typename T6, typename T7, typename T8, typename T9>
00251   struct TupleToPairs
00252   {
00253     typedef Pair<T1, typename TupleToPairs<T2,T3,T4,T5,T6,T7,T8,T9,Nil>::Type > Type;
00254   };
00255 
00259   template<typename T1>
00260   struct TupleToPairs<T1,Nil,Nil,Nil,Nil,Nil,Nil,Nil,Nil>
00261   {
00262     typedef Pair<T1,Nil> Type;
00263   };
00264   
00282   template<typename T1, typename T2 = Nil, typename T3 = Nil, 
00283            typename T4 = Nil, typename T5 = Nil,typename T6 = Nil, 
00284            typename T7 = Nil, typename T8 = Nil, typename T9 = Nil>
00285   class tuple : public TupleToPairs<T1,T2,T3,T4,T5,T6,T7,T8,T9>::Type
00286   {
00287   public:
00289     typedef typename TupleToPairs<T1,T2,T3,T4,T5,T6,T7,T8,T9>::Type FirstPair;
00290 
00291     tuple()
00292     {}
00293 
00294     tuple(typename TupleAccessTraits<T1>::ParameterType t1)
00295       : FirstPair(t1, nullType(), nullType(), nullType(), 
00296                   nullType(), nullType(), nullType(), nullType(), 
00297                   nullType())
00298     {}
00299 
00300     tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00301           typename TupleAccessTraits<T2>::ParameterType t2)
00302       : FirstPair(t1, t2, nullType(), nullType(), 
00303                   nullType(), nullType(), nullType(), nullType(), 
00304                   nullType())
00305     {}
00306 
00307     tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00308           typename TupleAccessTraits<T2>::ParameterType t2,
00309           typename TupleAccessTraits<T3>::ParameterType t3)
00310       : FirstPair(t1, t2, t3, 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           typename TupleAccessTraits<T4>::ParameterType t4)
00319       : FirstPair(t1, t2, t3, t4, 
00320                   nullType(), nullType(), nullType(), nullType(), 
00321                   nullType())
00322     {}
00323 
00324     tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00325           typename TupleAccessTraits<T2>::ParameterType t2,
00326           typename TupleAccessTraits<T3>::ParameterType t3,
00327           typename TupleAccessTraits<T4>::ParameterType t4,
00328           typename TupleAccessTraits<T5>::ParameterType t5)
00329       : FirstPair(t1, t2, t3, t4, 
00330                   t5, nullType(), nullType(), nullType(), 
00331                   nullType())
00332     {}
00333 
00334     tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00335           typename TupleAccessTraits<T2>::ParameterType t2,
00336           typename TupleAccessTraits<T3>::ParameterType t3,
00337           typename TupleAccessTraits<T4>::ParameterType t4,
00338           typename TupleAccessTraits<T5>::ParameterType t5,
00339           typename TupleAccessTraits<T6>::ParameterType t6)
00340       : FirstPair(t1, t2, t3, t4, 
00341                   t5, t6, nullType(), nullType(), 
00342                   nullType())
00343     {}
00344 
00345     tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00346           typename TupleAccessTraits<T2>::ParameterType t2,
00347           typename TupleAccessTraits<T3>::ParameterType t3,
00348           typename TupleAccessTraits<T4>::ParameterType t4,
00349           typename TupleAccessTraits<T5>::ParameterType t5,
00350           typename TupleAccessTraits<T6>::ParameterType t6,
00351           typename TupleAccessTraits<T7>::ParameterType t7)
00352       : FirstPair(t1, t2, t3, t4, 
00353                   t5, t6, t7, nullType(), 
00354                   nullType())
00355     {}
00356 
00357     tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00358           typename TupleAccessTraits<T2>::ParameterType t2,
00359           typename TupleAccessTraits<T3>::ParameterType t3,
00360           typename TupleAccessTraits<T4>::ParameterType t4,
00361           typename TupleAccessTraits<T5>::ParameterType t5,
00362           typename TupleAccessTraits<T6>::ParameterType t6,
00363           typename TupleAccessTraits<T7>::ParameterType t7,
00364           typename TupleAccessTraits<T8>::ParameterType t8)
00365       : FirstPair(t1, t2, t3, t4,
00366                   t5, t6, t7, t8, 
00367                   nullType())
00368     {}
00369 
00370     tuple(typename TupleAccessTraits<T1>::ParameterType t1,
00371           typename TupleAccessTraits<T2>::ParameterType t2,
00372           typename TupleAccessTraits<T3>::ParameterType t3,
00373           typename TupleAccessTraits<T4>::ParameterType t4,
00374           typename TupleAccessTraits<T5>::ParameterType t5,
00375           typename TupleAccessTraits<T6>::ParameterType t6,
00376           typename TupleAccessTraits<T7>::ParameterType t7,
00377           typename TupleAccessTraits<T8>::ParameterType t8,
00378           typename TupleAccessTraits<T9>::ParameterType t9)
00379       : FirstPair(t1, t2, t3, t4, t5, t6, t7, t8, t9)
00380     {}
00381 
00382     template<class U1, class U2>
00383     tuple& operator=(const Pair<U1,U2>& other)
00384     {
00385       FirstPair::operator=(other);
00386       return *this;
00387     }
00388   };
00389 
00390 #endif
00391 
00392   // be backwards compatible
00393 #define Tuple tuple
00394 
00395 #ifdef HAVE_TUPLE
00396   using std::tuple_element;
00397 #elif defined HAVE_TR1_TUPLE
00398   using std::tr1::tuple_element;
00399 #else
00400 
00403   template<int N, class Tuple>
00404   struct tuple_element
00405   {
00409     typedef typename tuple_element<N,typename Tuple::FirstPair>::type type;
00410     typedef typename tuple_element<N,typename Tuple::FirstPair>::type Type;
00411   };
00412   
00413   template<int N, typename T1, typename T2>
00414   struct tuple_element<N,Pair<T1,T2> >
00415   {
00419     typedef typename tuple_element<N-1,T2>::Type type;
00420     typedef typename tuple_element<N-1,T2>::Type Type;
00421   };
00422   
00426   template<typename T1, typename T2>
00427   struct tuple_element<0, Pair<T1,T2> >
00428   {
00432     typedef T1 type;
00433     typedef T1 Type;
00434   };
00435   
00436 #endif
00437 #define ElementType tuple_element
00438   
00439 #if defined HAVE_TUPLE || defined HAVE_TR1_TUPLE
00440 #ifdef HAVE_TUPLE
00441   #define TUPLE_NS std
00442   using std::get;
00443 #elif defined HAVE_TR1_TUPLE
00444   #define TUPLE_NS std::tr1
00445   using std::tr1::get;
00446 #endif
00447 
00448   // for backwards compatibility
00449   template<int i>
00450   struct Element{
00451     template<typename T1>
00452     static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::NonConstType get(T1& t)
00453     {
00454       return TUPLE_NS::get<i>(t);
00455     }
00456 
00457     template<typename T1>
00458     static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::ConstType get(const T1& t)
00459     {
00460       return TUPLE_NS::get<i>(t);
00461     }
00462   };
00463   #undef TUPLE_NS
00464   
00465 #else
00466 
00469   template<int N>
00470   struct Element
00471   {
00477     template<typename T1, typename T2>
00478     static typename TupleAccessTraits<
00479       typename tuple_element<N,Pair<T1,T2> >::type
00480     >::NonConstType
00481     get(Pair<T1,T2>& tuple)
00482     {
00483       return Element<N-1>::get(tuple.second());
00484     }
00485     
00491     template<typename T1, typename T2>
00492     static typename TupleAccessTraits<
00493       typename tuple_element<N,Pair<T1,T2> >::type
00494     >::ConstType
00495     get(const Pair<T1,T2>& tuple)
00496     {
00497       return Element<N-1>::get(tuple.second());
00498     }
00499   };
00500   
00504   template<>
00505   struct Element<0>
00506   {
00512     template<typename T1, typename T2>
00513     static typename TupleAccessTraits<T1>::NonConstType get(Pair<T1,T2>& tuple)
00514     {
00515       return tuple.first();
00516     }
00517     
00523     template<typename T1, typename T2>
00524     static typename TupleAccessTraits<T1>::ConstType get(const Pair<T1,T2>& tuple)
00525     {
00526       return tuple.first();
00527     }
00528   };
00529 
00530   template<int i, typename T1, typename T2, typename T3, typename T4,
00531            typename T5, typename T6, typename T7, typename T8, typename T9>
00532   typename TupleAccessTraits<typename tuple_element<i, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::type>
00533   ::NonConstType 
00534   get(tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>& t)
00535   {
00536     return Element<i>::get(t);
00537   }
00538 
00539   template<int i, typename T1, typename T2, typename T3, typename T4,
00540            typename T5, typename T6, typename T7, typename T8, typename T9>
00541   typename TupleAccessTraits<typename tuple_element<i, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::type>
00542   ::ConstType 
00543   get(const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9>& t)
00544   {
00545     return Element<i>::get(t);
00546   }
00547 
00548 #endif  
00549 
00550 #ifdef HAVE_TUPLE
00551   using std::tuple_size;
00552 #elif defined HAVE_TR1_TUPLE
00553   using std::tr1::tuple_size;
00554 #else
00555 
00559   template<class T>
00560   struct tuple_size
00561   {
00562     enum{ 
00563       // @brief The number of Elements in the tuple.
00564       value=tuple_size<typename T::FirstPair>::value
00565         };
00566     
00567     
00568   };
00569   
00570   template<typename T1, typename T2>
00571   struct tuple_size<Pair<T1,T2> >
00572   {
00573     enum{ value=1+tuple_size<T2>::value};
00574   };
00575   
00576   
00577   template<typename T1>
00578   struct tuple_size<Pair<T1,Nil> >
00579   {
00580     enum{ value=1};
00581   };
00582 
00583   template<>
00584   struct tuple_size<Pair<Nil,Nil> >
00585   {
00586     enum{ value=0};
00587   };
00588 #endif
00589 
00590 #define Size  tuple_size
00591 
00592 #ifdef HAVE_TUPLE    
00593   using std::tie;
00594   using std::make_tuple;
00595 #elif defined HAVE_TR1_TUPLE    
00596   using std::tr1::tie;
00597   using std::tr1::make_tuple;
00598 #endif
00599 
00600 #if defined HAVE_TUPLE || defined HAVE_TR1_TUPLE
00601   template<int i>
00602   struct tuple_writer
00603   {
00604     template<class Tuple>
00605     static std::ostream& put(std::ostream& os, const Tuple& t)
00606     {
00607       return tuple_writer<i-1>::put(os,t)<<", "<<get<i-1>(t);
00608     }
00609   };
00610   
00611   template<>
00612   struct tuple_writer<0>
00613   {
00614     template<class Tuple>
00615     static std::ostream& put(std::ostream& os, const Tuple& t)
00616     {
00617       return os;
00618     }
00619   };
00620 
00624   template<typename T1>
00625   inline std::ostream& operator<<( std::ostream& os, const tuple<T1> & t)
00626   {
00627     typedef tuple<T1> Tuple;
00628     return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00629   }
00630   
00631   template<typename T1, typename T2>
00632   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2> & t)
00633   {
00634     typedef tuple<T1,T2> Tuple;
00635     return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00636   }
00637   
00638   template<typename T1, typename T2, typename T3>
00639   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3> & t)
00640   {
00641     typedef tuple<T1,T2,T3> Tuple;
00642     return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00643   }
00644   
00645   template<typename T1, typename T2, typename T3, typename T4>
00646   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4> & t)
00647   {
00648     typedef tuple<T1,T2,T3,T4> Tuple;
00649     return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00650   }
00651   
00652   template<typename T1, typename T2, typename T3, typename T4, typename T5>
00653   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5> & t)
00654   {
00655     typedef tuple<T1,T2,T3,T4,T5> Tuple;
00656     return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00657   }
00658   
00659   template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
00660   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6> & t)
00661   {
00662     typedef tuple<T1,T2,T3,T4,T5,T6> Tuple;
00663     return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00664   }
00665   
00666   template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
00667   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7> & t)
00668   {
00669     typedef tuple<T1,T2,T3,T4,T5,T6,T7> Tuple;
00670     return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00671   }
00672   
00673   template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
00674            typename T8>
00675   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8> & t)
00676   {
00677     typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8> Tuple;
00678     return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00679   }
00680   
00681   template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
00682            typename T8, typename T9>
00683   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> & t)
00684   {
00685     typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> Tuple;
00686     return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00687   }
00688   
00689   template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
00690            typename T8, typename T9, typename T10>
00691   inline std::ostream& operator<<( std::ostream& os, const tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> & t)
00692   {
00693     typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Tuple;
00694     return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00695   }
00696 
00697 #else
00698 
00703   template<typename T1, typename T2, typename U1, typename U2>
00704   inline bool operator==(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00705   {
00706     return (tuple1.first()==tuple2.first() && tuple1.second()==tuple2.second());
00707   }
00708   
00714   template<typename T1, typename T2, typename U1, typename U2>
00715   inline bool operator!=(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00716   {
00717     return (tuple1.first()!=tuple2.first() || tuple1.second()!=tuple2.second());
00718   }
00719 
00725   template<typename T1, typename T2, typename U1, typename U2>
00726   inline bool operator<(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00727   {
00728     return tuple1.first() < tuple2.first()
00729       || (tuple1.first() == tuple2.first() && tuple1.second() < tuple2.second());
00730   }
00731 
00737   template<typename T1,typename U1>
00738   inline bool operator==(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00739   {
00740     return (tuple1.first()==tuple2.first());
00741   }
00742   
00748   template<typename T1, typename U1>
00749   inline bool operator!=(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00750   {
00751     dune_static_assert((IsInteroperable<T1,U1>::value), "T1 and U1 have to be interoperable, "<<
00752                         "i.e. either conversion from one to the other must exist!");
00753     return (tuple1.first()!=tuple2.first());
00754   }
00755 
00761   template<typename T1, typename U1>
00762   inline bool operator<(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00763   {
00764     return (tuple1.first()<tuple2.first());
00765   }
00766 
00774   template<typename T1,typename U1, typename U2>
00775   inline bool operator==(const Pair<T1,Nil>& tuple1, const Pair<U1,U2>& tuple2)
00776   {
00777     return false;
00778   }
00779   
00786   template<typename T1, typename U1, typename U2>
00787   inline bool operator!=(const Pair<T1,Nil>& tuple1, const Pair<U1,U2>& tuple2)
00788   {
00789     return true;
00790   }
00791 
00792 
00799   template<typename T1, typename T2, typename U1>
00800   inline bool operator==(const Pair<T1,T2>& tuple1, const Pair<U1,Nil>& tuple2)
00801   {
00802     return false;
00803   }
00804   
00811   template<typename T1, typename T2, typename U1>
00812   inline bool operator!=(const Pair<T1,T2>& tuple1, const Pair<U1,Nil>& tuple2)
00813   {
00814     return true;
00815   }
00816 
00822   template<typename T1, typename T2>
00823   inline Pair<T1,T2> makePair(const T1& first, const T2& second)
00824   {
00825     return Pair<T1,T2>(first, second);
00826   }
00827 
00831   template<typename T1, typename T2>
00832   inline std::ostream& operator<<(std::ostream& os, const Pair<T1,T2>& pair)
00833   {
00834     os<<pair.first()<<" "<<pair.second();
00835     return os;
00836   }
00837 
00838   template<typename T1>
00839   inline std::ostream& operator<<(std::ostream& os, const Pair<T1,Nil>& pair)
00840   {
00841     os<<pair.first();
00842     return os;
00843   }
00844 
00845   template<class T1>
00846   inline tuple<T1&> tie(T1& t1) {
00847     return tuple<T1&> (t1);
00848   }
00849 
00850   template<class T1, class T2>
00851   inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {
00852     return tuple<T1&, T2&> (t1, t2);
00853   }
00854 
00855   template<class T1, class T2, class T3>
00856   inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {
00857     return tuple<T1&, T2&, T3&> (t1, t2, t3);
00858   }
00859 
00860   template<class T1, class T2, class T3, class T4>
00861   inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
00862     return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);
00863   }
00864 
00865   template<class T1, class T2, class T3, class T4, class T5>
00866   inline tuple<T1&, T2&, T3&, T4&, T5&>
00867   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
00868     return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
00869   }
00870 
00871   template<class T1, class T2, class T3, class T4, class T5, class T6>
00872   inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
00873   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
00874     return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
00875   }
00876 
00877   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
00878   inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
00879   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
00880     return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
00881   }
00882 
00883   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00884            class T8>
00885   inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
00886   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
00887     return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
00888       (t1, t2, t3, t4, t5, t6, t7, t8);
00889   }
00890 
00891   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00892            class T8, class T9>
00893   inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
00894   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9) {
00895     return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
00896       (t1, t2, t3, t4, t5, t6, t7, t8, t9);
00897   }
00898 
00899   template<class T1>
00900   inline tuple<T1> make_tuple(const T1& t1) {
00901     return tuple<T1> (t1);
00902   }
00903 
00904   template<class T1, class T2>
00905   inline tuple<T1, T2> make_tuple(const T1& t1, const T2& t2) {
00906     return tuple<T1, T2> (t1, t2);
00907   }
00908 
00909   template<class T1, class T2, class T3>
00910   inline tuple<T1, T2, T3> make_tuple(const T1& t1, const T2& t2, const T3& t3) {
00911     return tuple<T1, T2, T3> (t1, t2, t3);
00912   }
00913 
00914   template<class T1, class T2, class T3, class T4>
00915   inline tuple<T1, T2, T3, T4> make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
00916     return tuple<T1, T2, T3, T4> (t1, t2, t3, t4);
00917   }
00918 
00919   template<class T1, class T2, class T3, class T4, class T5>
00920   inline tuple<T1, T2, T3, T4, T5>
00921   make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) {
00922     return tuple<T1, T2, T3, T4, T5> (t1, t2, t3, t4, t5);
00923   }
00924 
00925   template<class T1, class T2, class T3, class T4, class T5, class T6>
00926   inline tuple<T1, T2, T3, T4, T5, T6>
00927   make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) {
00928     return tuple<T1, T2, T3, T4, T5, T6> (t1, t2, t3, t4, t5, t6);
00929   }
00930 
00931   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
00932   inline tuple<T1, T2, T3, T4, T5, T6, T7>
00933   make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00934              const T7& t7) {
00935     return tuple<T1, T2, T3, T4, T5, T6, T7> (t1, t2, t3, t4, t5, t6, t7);
00936   }
00937 
00938   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00939            class T8>
00940   inline tuple<T1, T2, T3, T4, T5, T6, T7, T8>
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, const T8& t8) {
00943     return tuple<T1, T2, T3, T4, T5, T6, T7, T8>
00944       (t1, t2, t3, t4, t5, t6, t7, t8);
00945   }
00946 
00947   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00948            class T8, class T9>
00949   inline tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
00950   make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00951              const  T7& t7, const T8& t8, const T9& t9) {
00952     return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
00953       (t1, t2, t3, t4, t5, t6, t7, t8, t9);
00954   }
00955 
00956   template<typename T1, typename TT>
00957   template<typename T2, typename T3, typename T4, typename T5,
00958            typename T6, typename T7, typename T8, typename T9>
00959   inline Pair<T1,TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first, 
00960                            T2& t2, T3& t3, T4& t4, T5& t5, 
00961                            T6& t6, T7& t7, T8& t8, T9& t9)
00962     : first_(first), second_(t2,t3,t4,t5,t6,t7,t8,t9, nullType())
00963   {}
00964 
00965   template <typename T1, typename TT>
00966   inline Pair<T1, TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first, TT& second) 
00967     : first_(first), second_(second)
00968   {}
00969   
00970   template<typename T1, typename T2>
00971   inline Pair<T1,T2>::Pair()
00972     : first_(), second_()
00973   {}
00974   
00975   template<typename T1, typename T2>
00976   template<typename U1, typename U2>
00977   inline Pair<T1,T2>::Pair(const Pair<U1,U2>& other)
00978     : first_(other.first_), second_(other.second_)
00979   {}
00980   
00981   template<typename T1, typename T2>
00982   template<typename U1, typename U2>
00983   inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair<U1,U2>& other)
00984   {
00985     first_=other.first_;
00986     second_=other.second_;
00987     return *this;
00988   }
00989 
00990   template<typename T1, typename T2>
00991   inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair& other)
00992   {
00993     first_=other.first_;
00994     second_=other.second_;
00995     return *this;
00996   }
00997 
00998   template<typename T1, typename T2>
00999   inline typename TupleAccessTraits<T1>::NonConstType 
01000   Pair<T1,T2>::first()
01001   {
01002     return first_;
01003   }
01004   
01005   template<typename T1, typename T2>
01006   inline typename TupleAccessTraits<T1>::ConstType 
01007   Pair<T1,T2>::first() const
01008   {
01009     return first_;
01010   }
01011  
01012   
01013   template<typename T1, typename T2>
01014   inline typename TupleAccessTraits<T2>::NonConstType
01015   Pair<T1,T2>::second()
01016   {
01017     return second_;
01018   }
01019   
01020   template<typename T1, typename T2>
01021   inline typename TupleAccessTraits<T2>::ConstType
01022   Pair<T1,T2>::second() const
01023   {
01024     return second_;
01025   }
01026 
01027   template<typename T1>
01028   inline Pair<T1,Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
01029                             const Nil&, const Nil&, const Nil&, const Nil&,
01030                             const Nil&, const Nil&, const Nil&, const Nil&)
01031     : first_(first)
01032   {}
01033 
01034   template <typename T1>
01035   inline Pair<T1, Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
01036                              const Nil&)
01037     : first_(first)
01038   {}
01039 
01040   template<typename T1>
01041   inline Pair<T1,Nil>::Pair()
01042     : first_()
01043   {}
01044   
01045   template<typename T1>
01046   template<typename T2>
01047   inline Pair<T1,Nil>::Pair(const Pair<T2,Nil>& other)
01048     : first_(other.first_)
01049   {}
01050 
01051   template<typename T1>
01052   template<typename T2>
01053   Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair<T2,Nil>& other)
01054   {
01055     first_ = other.first_;
01056     return *this;
01057   }
01058 
01059   
01060   template<typename T1>
01061   Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair& other)
01062   {
01063     first_ = other.first_;
01064     return *this;
01065   }
01066 
01067   template<typename T1>
01068   inline typename TupleAccessTraits<T1>::NonConstType 
01069   Pair<T1,Nil>::first()
01070   {
01071     return first_;
01072   }
01073   
01074   template<typename T1>
01075   inline typename TupleAccessTraits<T1>::ConstType 
01076   Pair<T1,Nil>::first() const
01077   {
01078     return first_;
01079   }
01080  
01081 #endif
01082 }
01083 #endif

Generated on 6 Nov 2008 with Doxygen (ver 1.5.6) [logfile].