tuples.hh

Go to the documentation of this file.
00001 // $Id: tuples.hh 5002 2007-10-04 09:56:37Z mblatt $
00002 #ifndef DUNE_TUPLES_HH
00003 #define DUNE_TUPLES_HH
00004 
00005 #include<ostream>
00006 #include"typetraits.hh"
00007 #include"helpertemplates.hh"
00008 
00009 #ifdef HAVE_TUPLE
00010 #include <tuple>
00011 #endif
00012 #ifdef 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 #ifdef HAVE_TR1_TUPLE
00440   using std::tr1::get;
00441 
00442   // for backwards compatibility
00443     template<int i>
00444   struct Element{
00445     template<typename T1>
00446     static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::NonConstType get(T1& t)
00447     {
00448       return std::tr1::get<i>(t);
00449     }
00450 
00451     template<typename T1>
00452     static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::ConstType get(const T1& t)
00453     {
00454       return std::tr1::get<i>(t);
00455     }
00456   };
00457 #elif defined HAVE_TUPLE
00458   using std::get;
00459 
00460   // for backwards compatibility
00461     template<int i>
00462   struct Element{
00463     template<typename T1>
00464     static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::NonConstType get(T1& t)
00465     {
00466       return std::get<i>(t);
00467     }
00468 
00469     template<typename T1>
00470     static typename TupleAccessTraits<typename tuple_element<i,T1>::type>::ConstType get(const T1& t)
00471     {
00472       return std::get<i>(t);
00473     }
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 #endif  
00550 
00551 #ifdef HAVE_TR1_TUPLE
00552   using std::tr1::tuple_size;
00553 #elif defined HAVE_TUPLE
00554   using std::tuple_size;
00555 #else
00556 
00560   template<class T>
00561   struct tuple_size
00562   {
00563     enum{ 
00564       // @brief The number of Elements in the tuple.
00565       value=tuple_size<typename T::FirstPair>::value
00566         };
00567     
00568     
00569   };
00570   
00571   template<typename T1, typename T2>
00572   struct tuple_size<Pair<T1,T2> >
00573   {
00574     enum{ value=1+tuple_size<T2>::value};
00575   };
00576   
00577   
00578   template<typename T1>
00579   struct tuple_size<Pair<T1,Nil> >
00580   {
00581     enum{ value=1};
00582   };
00583 
00584   template<>
00585   struct tuple_size<Pair<Nil,Nil> >
00586   {
00587     enum{ value=0};
00588   };
00589 #endif
00590 
00591 #define Size  tuple_size
00592 
00593 #ifdef HAVE_TR1_TUPLE    
00594   using std::tr1::tie;
00595   using std::tr1::make_tuple;
00596 #endif
00597 #ifdef HAVE_TUPLE    
00598   using std::tie;
00599   using std::make_tuple;
00600 #endif
00601 
00602 #if defined HAVE_TUPLE || defined HAVE_TR1_TUPLE
00603   template<int i>
00604   struct tuple_writer
00605   {
00606     template<class Tuple>
00607     static std::ostream& put(std::ostream& os, const Tuple& t)
00608     {
00609       return tuple_writer<i-1>::put(os,t)<<", "<<get<i-1>(t);
00610     }
00611   };
00612   
00613   template<>
00614   struct tuple_writer<0>
00615   {
00616     template<class Tuple>
00617     static std::ostream& put(std::ostream& os, const Tuple& t)
00618     {
00619       return os;
00620     }
00621   };
00622 
00626   template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7,
00627            typename T8, typename T9>
00628   inline std::ostream& operator<<( std::ostream& os, tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> t)
00629   {
00630     typedef tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> Tuple;
00631     return tuple_writer<tuple_size<Tuple>::value>::put(os, t);
00632   }
00633 
00634   
00635 #else
00636 
00641   template<typename T1, typename T2, typename U1, typename U2>
00642   inline bool operator==(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00643   {
00644     return (tuple1.first()==tuple2.first() && tuple1.second()==tuple2.second());
00645   }
00646   
00652   template<typename T1, typename T2, typename U1, typename U2>
00653   inline bool operator!=(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00654   {
00655     return (tuple1.first()!=tuple2.first() || tuple1.second()!=tuple2.second());
00656   }
00657 
00663   template<typename T1, typename T2, typename U1, typename U2>
00664   inline bool operator<(const Pair<T1,T2>& tuple1, const Pair<U1,U2>& tuple2)
00665   {
00666     return tuple1.first() < tuple2.first()
00667       || (tuple1.first() == tuple2.first() && tuple1.second() < tuple2.second());
00668   }
00669 
00675   template<typename T1,typename U1>
00676   inline bool operator==(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00677   {
00678     return (tuple1.first()==tuple2.first());
00679   }
00680   
00686   template<typename T1, typename U1>
00687   inline bool operator!=(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00688   {
00689     IsTrue<IsInteroperable<T1,U1>::value>::yes();
00690     return (tuple1.first()!=tuple2.first());
00691   }
00692 
00698   template<typename T1, typename U1>
00699   inline bool operator<(const Pair<T1,Nil>& tuple1, const Pair<U1,Nil>& tuple2)
00700   {
00701     return (tuple1.first()<tuple2.first());
00702   }
00703 
00711   template<typename T1,typename U1, typename U2>
00712   inline bool operator==(const Pair<T1,Nil>& tuple1, const Pair<U1,U2>& tuple2)
00713   {
00714     return false;
00715   }
00716   
00723   template<typename T1, typename U1, typename U2>
00724   inline bool operator!=(const Pair<T1,Nil>& tuple1, const Pair<U1,U2>& tuple2)
00725   {
00726     return true;
00727   }
00728 
00729 
00736   template<typename T1, typename T2, typename U1>
00737   inline bool operator==(const Pair<T1,T2>& tuple1, const Pair<U1,Nil>& tuple2)
00738   {
00739     return false;
00740   }
00741   
00748   template<typename T1, typename T2, typename U1>
00749   inline bool operator!=(const Pair<T1,T2>& tuple1, const Pair<U1,Nil>& tuple2)
00750   {
00751     return true;
00752   }
00753 
00759   template<typename T1, typename T2>
00760   inline Pair<T1,T2> makePair(const T1& first, const T2& second)
00761   {
00762     return Pair<T1,T2>(first, second);
00763   }
00764 
00768   template<typename T1, typename T2>
00769   inline std::ostream& operator<<(std::ostream& os, const Pair<T1,T2>& pair)
00770   {
00771     os<<pair.first()<<" "<<pair.second();
00772     return os;
00773   }
00774 
00775   template<typename T1>
00776   inline std::ostream& operator<<(std::ostream& os, const Pair<T1,Nil>& pair)
00777   {
00778     os<<pair.first();
00779     return os;
00780   }
00781 
00782   template<class T1>
00783   inline tuple<T1&> tie(T1& t1) {
00784     return tuple<T1&> (t1);
00785   }
00786 
00787   template<class T1, class T2>
00788   inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {
00789     return tuple<T1&, T2&> (t1, t2);
00790   }
00791 
00792   template<class T1, class T2, class T3>
00793   inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {
00794     return tuple<T1&, T2&, T3&> (t1, t2, t3);
00795   }
00796 
00797   template<class T1, class T2, class T3, class T4>
00798   inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
00799     return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);
00800   }
00801 
00802   template<class T1, class T2, class T3, class T4, class T5>
00803   inline tuple<T1&, T2&, T3&, T4&, T5&>
00804   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
00805     return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
00806   }
00807 
00808   template<class T1, class T2, class T3, class T4, class T5, class T6>
00809   inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
00810   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
00811     return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
00812   }
00813 
00814   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
00815   inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
00816   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
00817     return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
00818   }
00819 
00820   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00821            class T8>
00822   inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
00823   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
00824     return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
00825       (t1, t2, t3, t4, t5, t6, t7, t8);
00826   }
00827 
00828   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00829            class T8, class T9>
00830   inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
00831   tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9) {
00832     return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
00833       (t1, t2, t3, t4, t5, t6, t7, t8, t9);
00834   }
00835 
00836   template<class T1>
00837   inline tuple<T1> make_tuple(const T1& t1) {
00838     return tuple<T1> (t1);
00839   }
00840 
00841   template<class T1, class T2>
00842   inline tuple<T1, T2> make_tuple(const T1& t1, const T2& t2) {
00843     return tuple<T1, T2> (t1, t2);
00844   }
00845 
00846   template<class T1, class T2, class T3>
00847   inline tuple<T1, T2, T3> make_tuple(const T1& t1, const T2& t2, const T3& t3) {
00848     return tuple<T1, T2, T3> (t1, t2, t3);
00849   }
00850 
00851   template<class T1, class T2, class T3, class T4>
00852   inline tuple<T1, T2, T3, T4> make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
00853     return tuple<T1, T2, T3, T4> (t1, t2, t3, t4);
00854   }
00855 
00856   template<class T1, class T2, class T3, class T4, class T5>
00857   inline tuple<T1, T2, T3, T4, T5>
00858   make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) {
00859     return tuple<T1, T2, T3, T4, T5> (t1, t2, t3, t4, t5);
00860   }
00861 
00862   template<class T1, class T2, class T3, class T4, class T5, class T6>
00863   inline tuple<T1, T2, T3, T4, T5, T6>
00864   make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) {
00865     return tuple<T1, T2, T3, T4, T5, T6> (t1, t2, t3, t4, t5, t6);
00866   }
00867 
00868   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
00869   inline tuple<T1, T2, T3, T4, T5, T6, T7>
00870   make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00871              const T7& t7) {
00872     return tuple<T1, T2, T3, T4, T5, T6, T7> (t1, t2, t3, t4, t5, t6, t7);
00873   }
00874 
00875   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00876            class T8>
00877   inline tuple<T1, T2, T3, T4, T5, T6, T7, T8>
00878   make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00879              const T7& t7, const T8& t8) {
00880     return tuple<T1, T2, T3, T4, T5, T6, T7, T8>
00881       (t1, t2, t3, t4, t5, t6, t7, t8);
00882   }
00883 
00884   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
00885            class T8, class T9>
00886   inline tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
00887   make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
00888              const  T7& t7, const T8& t8, const T9& t9) {
00889     return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
00890       (t1, t2, t3, t4, t5, t6, t7, t8, t9);
00891   }
00892 
00893   template<typename T1, typename TT>
00894   template<typename T2, typename T3, typename T4, typename T5,
00895            typename T6, typename T7, typename T8, typename T9>
00896   inline Pair<T1,TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first, 
00897                            T2& t2, T3& t3, T4& t4, T5& t5, 
00898                            T6& t6, T7& t7, T8& t8, T9& t9)
00899     : first_(first), second_(t2,t3,t4,t5,t6,t7,t8,t9, nullType())
00900   {}
00901 
00902   template <typename T1, typename TT>
00903   inline Pair<T1, TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first, TT& second) 
00904     : first_(first), second_(second)
00905   {}
00906   
00907   template<typename T1, typename T2>
00908   inline Pair<T1,T2>::Pair()
00909     : first_(), second_()
00910   {}
00911   
00912   template<typename T1, typename T2>
00913   template<typename U1, typename U2>
00914   inline Pair<T1,T2>::Pair(const Pair<U1,U2>& other)
00915     : first_(other.first_), second_(other.second_)
00916   {}
00917   
00918   template<typename T1, typename T2>
00919   template<typename U1, typename U2>
00920   inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair<U1,U2>& other)
00921   {
00922     first_=other.first_;
00923     second_=other.second_;
00924     return *this;
00925   }
00926 
00927   template<typename T1, typename T2>
00928   inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair& other)
00929   {
00930     first_=other.first_;
00931     second_=other.second_;
00932     return *this;
00933   }
00934 
00935   template<typename T1, typename T2>
00936   inline typename TupleAccessTraits<T1>::NonConstType 
00937   Pair<T1,T2>::first()
00938   {
00939     return first_;
00940   }
00941   
00942   template<typename T1, typename T2>
00943   inline typename TupleAccessTraits<T1>::ConstType 
00944   Pair<T1,T2>::first() const
00945   {
00946     return first_;
00947   }
00948  
00949   
00950   template<typename T1, typename T2>
00951   inline typename TupleAccessTraits<T2>::NonConstType
00952   Pair<T1,T2>::second()
00953   {
00954     return second_;
00955   }
00956   
00957   template<typename T1, typename T2>
00958   inline typename TupleAccessTraits<T2>::ConstType
00959   Pair<T1,T2>::second() const
00960   {
00961     return second_;
00962   }
00963 
00964   template<typename T1>
00965   inline Pair<T1,Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
00966                             const Nil&, const Nil&, const Nil&, const Nil&,
00967                             const Nil&, const Nil&, const Nil&, const Nil&)
00968     : first_(first)
00969   {}
00970 
00971   template <typename T1>
00972   inline Pair<T1, Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
00973                              const Nil&)
00974     : first_(first)
00975   {}
00976 
00977   template<typename T1>
00978   inline Pair<T1,Nil>::Pair()
00979     : first_()
00980   {}
00981   
00982   template<typename T1>
00983   template<typename T2>
00984   inline Pair<T1,Nil>::Pair(const Pair<T2,Nil>& other)
00985     : first_(other.first_)
00986   {}
00987 
00988   template<typename T1>
00989   template<typename T2>
00990   Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair<T2,Nil>& other)
00991   {
00992     first_ = other.first_;
00993     return *this;
00994   }
00995 
00996   
00997   template<typename T1>
00998   Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair& other)
00999   {
01000     first_ = other.first_;
01001     return *this;
01002   }
01003 
01004   template<typename T1>
01005   inline typename TupleAccessTraits<T1>::NonConstType 
01006   Pair<T1,Nil>::first()
01007   {
01008     return first_;
01009   }
01010   
01011   template<typename T1>
01012   inline typename TupleAccessTraits<T1>::ConstType 
01013   Pair<T1,Nil>::first() const
01014   {
01015     return first_;
01016   }
01017  
01018 #endif
01019 }
01020 #endif

Generated on 9 Apr 2008 with Doxygen (ver 1.5.2) [logfile].