tuple

Go to the documentation of this file.
00001 // class template tuple -*- C++ -*-
00002 
00003 // Copyright (C) 2004, 2005 Free Software Foundation, Inc.
00004 //
00005 // This file is part of the GNU ISO C++ Library.  This library is free
00006 // software; you can redistribute it and/or modify it under the
00007 // terms of the GNU General Public License as published by the
00008 // Free Software Foundation; either version 2, or (at your option)
00009 // any later version.
00010 
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 // GNU General Public License for more details.
00015 
00016 // You should have received a copy of the GNU General Public License along
00017 // with this library; see the file COPYING.  If not, write to the Free
00018 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
00019 // USA.
00020 
00021 // As a special exception, you may use this file as part of a free software
00022 // library without restriction.  Specifically, if other files instantiate
00023 // templates or use macros or inline functions from this file, or you compile
00024 // this file and link it with other files to produce an executable, this
00025 // file does not by itself cause the resulting executable to be covered by
00026 // the GNU General Public License.  This exception does not however
00027 // invalidate any other reasons why the executable file might be covered by
00028 // the GNU General Public License.
00029 
00030 /** @file 
00031  *  This is a TR1 C++ Library header. 
00032  */
00033 
00034 // Chris Jefferson <chris@bubblescope.net>
00035 
00036 // This header is automatically generated: see maketuple.c for details.
00037 
00038 #ifndef _TUPLE
00039 #define _TUPLE 1
00040 
00041 #include <tr1/utility>
00042 #include <tr1/functional>
00043 
00044 namespace std
00045 {
00046 namespace tr1
00047 {
00048   // An implementation specific class which is used in the tuple class
00049   // when the tuple is not maximum possible size.
00050   struct _NullClass { };
00051 
00052   template<typename _Tp0 = _NullClass, typename _Tp1 = _NullClass,
00053        typename _Tp2 = _NullClass, typename _Tp3 = _NullClass,
00054        typename _Tp4 = _NullClass, typename _Tp5 = _NullClass,
00055        typename _Tp6 = _NullClass, typename _Tp7 = _NullClass,
00056        typename _Tp8 = _NullClass, typename _Tp9 = _NullClass>
00057     class tuple;
00058 
00059   /// Gives the type of the ith element of a given tuple type.
00060   template<int __i, typename _Tp>
00061     struct tuple_element;
00062 
00063   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00064        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00065        typename _Tp8, typename _Tp9>
00066     struct tuple_element<0, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
00067                   _Tp7, _Tp8, _Tp9> >
00068     { typedef _Tp0 type; };
00069 
00070   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00071        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00072        typename _Tp8, typename _Tp9>
00073     struct tuple_element<1, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
00074                   _Tp7, _Tp8, _Tp9> >
00075     { typedef _Tp1 type; };
00076 
00077   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00078        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00079        typename _Tp8, typename _Tp9>
00080     struct tuple_element<2, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
00081                   _Tp7, _Tp8, _Tp9> >
00082     { typedef _Tp2 type; };
00083 
00084   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00085        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00086        typename _Tp8, typename _Tp9>
00087     struct tuple_element<3, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
00088                   _Tp7, _Tp8, _Tp9> >
00089     { typedef _Tp3 type; };
00090 
00091   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00092        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00093        typename _Tp8, typename _Tp9>
00094     struct tuple_element<4, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
00095                   _Tp7, _Tp8, _Tp9> >
00096     { typedef _Tp4 type; };
00097 
00098   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00099        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00100        typename _Tp8, typename _Tp9>
00101     struct tuple_element<5, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
00102                   _Tp7, _Tp8, _Tp9> >
00103     { typedef _Tp5 type; };
00104 
00105   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00106        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00107        typename _Tp8, typename _Tp9>
00108     struct tuple_element<6, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
00109                   _Tp7, _Tp8, _Tp9> >
00110     { typedef _Tp6 type; };
00111 
00112   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00113        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00114        typename _Tp8, typename _Tp9>
00115     struct tuple_element<7, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
00116                   _Tp7, _Tp8, _Tp9> >
00117     { typedef _Tp7 type; };
00118 
00119   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00120        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00121        typename _Tp8, typename _Tp9>
00122     struct tuple_element<8, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
00123                   _Tp7, _Tp8, _Tp9> >
00124     { typedef _Tp8 type; };
00125 
00126   /// @brief  class tuple_element
00127   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00128        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00129        typename _Tp8, typename _Tp9>
00130     struct tuple_element<9, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
00131                   _Tp7, _Tp8, _Tp9> >
00132     { typedef _Tp9 type; };
00133 
00134   /// Finds the size of a given tuple type.
00135   template<typename _Tp>
00136     struct tuple_size;
00137 
00138   template<>
00139     struct tuple_size<tuple<_NullClass, _NullClass, _NullClass, _NullClass,
00140                 _NullClass, _NullClass, _NullClass, _NullClass,
00141                 _NullClass, _NullClass> >
00142     { static const int value = 0; };
00143 
00144   template< typename _Tp0>
00145     struct tuple_size<tuple< _Tp0, _NullClass, _NullClass, _NullClass,
00146                 _NullClass, _NullClass, _NullClass, _NullClass,
00147                 _NullClass, _NullClass> >
00148     { static const int value = 1; };
00149 
00150   template<typename _Tp0, typename _Tp1>
00151     struct tuple_size<tuple<_Tp0, _Tp1, _NullClass, _NullClass, _NullClass,
00152                 _NullClass, _NullClass, _NullClass, _NullClass,
00153                 _NullClass> >
00154     { static const int value = 2; };
00155 
00156   template<typename _Tp0, typename _Tp1, typename _Tp2>
00157     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _NullClass, _NullClass,
00158                 _NullClass, _NullClass, _NullClass, _NullClass,
00159                 _NullClass> >
00160     { static const int value = 3; };
00161 
00162   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3>
00163     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _Tp3, _NullClass, _NullClass,
00164                 _NullClass, _NullClass, _NullClass, _NullClass> >
00165     { static const int value = 4; };
00166 
00167   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00168        typename _Tp4>
00169     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _NullClass,
00170                 _NullClass, _NullClass, _NullClass, _NullClass> >
00171     { static const int value = 5; };
00172 
00173   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00174        typename _Tp4, typename _Tp5>
00175     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _NullClass,
00176                 _NullClass, _NullClass, _NullClass> >
00177     { static const int value = 6; };
00178 
00179   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00180        typename _Tp4, typename _Tp5, typename _Tp6>
00181     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, 
00182                 _NullClass, _NullClass, _NullClass> >
00183     { static const int value = 7; };
00184 
00185   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00186        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7>
00187     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, 
00188                 _NullClass, _NullClass> >
00189     { static const int value = 8; };
00190 
00191   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00192        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00193        typename _Tp8>
00194     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7,
00195                 _Tp8,  _NullClass> >
00196     { static const int value = 9; };
00197 
00198   /// @brief  class tuple_size
00199   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00200        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00201        typename _Tp8, typename _Tp9>
00202     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7,
00203                 _Tp8, _Tp9> >
00204     { static const int value = 10; };
00205 
00206   // Adds a const reference to a non-reference type.
00207   template<typename _Tp>
00208     struct __add_c_ref
00209     { typedef const _Tp& type; };
00210 
00211   template<typename _Tp>
00212     struct __add_c_ref<_Tp&>
00213     { typedef _Tp& type; };
00214 
00215   // Adds a reference to a non-reference type.
00216   template<typename _Tp>
00217     struct __add_ref
00218     { typedef _Tp& type; };
00219 
00220   template<typename _Tp>
00221     struct __add_ref<_Tp&>
00222     { typedef _Tp& type; };
00223 
00224   // The empty tuple.
00225   template<>
00226     class tuple<_NullClass, _NullClass, _NullClass, _NullClass, _NullClass,
00227             _NullClass, _NullClass, _NullClass, _NullClass, _NullClass>
00228     {
00229     public:
00230       tuple()
00231       { }
00232 
00233       tuple(const tuple& __in)
00234       { }
00235 
00236       tuple& operator=(const tuple& __in)
00237       { return *this; }
00238     };
00239 
00240   template< typename _Tp0>
00241     class tuple< _Tp0, _NullClass, _NullClass, _NullClass, _NullClass,
00242             _NullClass, _NullClass, _NullClass, _NullClass, _NullClass>
00243     {
00244       _Tp0 _M_t0;
00245 
00246     public:
00247       tuple()
00248       { }
00249 
00250       explicit tuple( typename __add_c_ref<_Tp0>::type __in0):
00251          _M_t0(__in0)
00252       { }
00253 
00254       tuple(const tuple& __in):
00255          _M_t0(__in._M_t0)
00256       { }
00257 
00258       template< typename _Up0>
00259         tuple(const tuple< _Up0>& __in):
00260        _M_t0(__in._M_t0)
00261         { }
00262 
00263       tuple&
00264       operator=(const tuple& __in)
00265       {
00266         _M_t0=__in._M_t0;
00267         return *this;
00268       }
00269 
00270       template< typename _Up0>
00271         tuple&
00272         operator=(const tuple< _Up0>& __in)
00273         {
00274       _M_t0=__in._M_t0;
00275       return *this;
00276         }
00277 
00278       template<int __i, typename _Up>
00279         friend class __get_helper;
00280       template<typename, typename, typename, typename, typename, typename,
00281            typename, typename, typename, typename>
00282         friend class tuple;
00283   };
00284 
00285   template<typename _Tp0, typename _Tp1>
00286     class tuple<_Tp0, _Tp1, _NullClass, _NullClass, _NullClass, _NullClass,
00287             _NullClass, _NullClass, _NullClass, _NullClass>
00288     {
00289       _Tp0 _M_t0;
00290       _Tp1 _M_t1;
00291 
00292     public:
00293       tuple()
00294       { }
00295 
00296       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
00297              typename __add_c_ref<_Tp1>::type __in1):
00298         _M_t0(__in0), _M_t1(__in1)
00299       { }
00300 
00301       tuple(const tuple& __in):
00302         _M_t0(__in._M_t0), _M_t1(__in._M_t1)
00303       { }
00304 
00305       template<typename _Up0, typename _Up1>
00306         tuple(const tuple<_Up0, _Up1>& __in):
00307       _M_t0(__in._M_t0), _M_t1(__in._M_t1)
00308         { }
00309 
00310       template<class _Up1, class _Up2>
00311         tuple(const std::pair<_Up1, _Up2>& __u):
00312            _M_t0(__u.first), _M_t1(__u.second)
00313         { }
00314 
00315       tuple&
00316       operator=(const tuple& __in)
00317       {
00318         _M_t0=__in._M_t0;
00319         _M_t1=__in._M_t1;
00320         return *this;
00321       }
00322 
00323       template<typename _Up0, typename _Up1>
00324         tuple&
00325         operator=(const tuple<_Up0, _Up1>& __in)
00326         {
00327       _M_t0=__in._M_t0;
00328       _M_t1=__in._M_t1;
00329       return *this;
00330         }
00331 
00332       template<int __i, typename _Up>
00333         friend class __get_helper;
00334       template<typename, typename, typename, typename, typename, typename,
00335            typename, typename, typename, typename>
00336         friend class tuple;
00337   };
00338 
00339   template<typename _Tp0, typename _Tp1, typename _Tp2>
00340     class tuple<_Tp0, _Tp1, _Tp2, _NullClass, _NullClass, _NullClass,
00341             _NullClass, _NullClass, _NullClass, _NullClass>
00342     {
00343       _Tp0 _M_t0;
00344       _Tp1 _M_t1;
00345       _Tp2 _M_t2;
00346 
00347     public:
00348       tuple()
00349       { }
00350 
00351       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
00352              typename __add_c_ref<_Tp1>::type __in1,
00353              typename __add_c_ref<_Tp2>::type __in2):
00354         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2)
00355       { }
00356 
00357       tuple(const tuple& __in):
00358         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2)
00359       { }
00360 
00361       template<typename _Up0, typename _Up1, typename _Up2>
00362         tuple(const tuple<_Up0, _Up1, _Up2>& __in):
00363       _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2)
00364         { }
00365 
00366       tuple&
00367       operator=(const tuple& __in)
00368       {
00369         _M_t0=__in._M_t0;
00370         _M_t1=__in._M_t1;
00371         _M_t2=__in._M_t2;
00372         return *this;
00373       }
00374 
00375       template<typename _Up0, typename _Up1, typename _Up2>
00376         tuple&
00377         operator=(const tuple<_Up0, _Up1, _Up2>& __in)
00378         {
00379       _M_t0=__in._M_t0;
00380       _M_t1=__in._M_t1;
00381       _M_t2=__in._M_t2;
00382       return *this;
00383         }
00384 
00385       template<int __i, typename _Up>
00386         friend class __get_helper;
00387       template<typename, typename, typename, typename, typename, typename,
00388            typename, typename, typename, typename>
00389         friend class tuple;
00390   };
00391 
00392   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3>
00393     class tuple<_Tp0, _Tp1, _Tp2, _Tp3, _NullClass, _NullClass, _NullClass,
00394             _NullClass, _NullClass, _NullClass>
00395     {
00396       _Tp0 _M_t0;
00397       _Tp1 _M_t1;
00398       _Tp2 _M_t2;
00399       _Tp3 _M_t3;
00400 
00401     public:
00402       tuple()
00403       { }
00404 
00405       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
00406              typename __add_c_ref<_Tp1>::type __in1,
00407              typename __add_c_ref<_Tp2>::type __in2,
00408              typename __add_c_ref<_Tp3>::type __in3):
00409         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2), _M_t3(__in3)
00410       { }
00411 
00412       tuple(const tuple& __in):
00413         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
00414         _M_t3(__in._M_t3)
00415       { }
00416 
00417       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3>
00418         tuple(const tuple<_Up0, _Up1, _Up2, _Up3>& __in):
00419       _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
00420       _M_t3(__in._M_t3)
00421         { }
00422 
00423       tuple&
00424       operator=(const tuple& __in)
00425       {
00426         _M_t0=__in._M_t0;
00427         _M_t1=__in._M_t1;
00428         _M_t2=__in._M_t2;
00429         _M_t3=__in._M_t3;
00430         return *this;
00431       }
00432 
00433       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3>
00434         tuple&
00435         operator=(const tuple<_Up0, _Up1, _Up2, _Up3>& __in)
00436         {
00437       _M_t0=__in._M_t0;
00438       _M_t1=__in._M_t1;
00439       _M_t2=__in._M_t2;
00440       _M_t3=__in._M_t3;
00441       return *this;
00442         }
00443 
00444       template<int __i, typename _Up>
00445         friend class __get_helper;
00446       template<typename, typename, typename, typename, typename, typename,
00447            typename, typename, typename, typename>
00448         friend class tuple;
00449   };
00450 
00451   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00452        typename _Tp4>
00453     class tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _NullClass, _NullClass,
00454             _NullClass, _NullClass, _NullClass>
00455     {
00456       _Tp0 _M_t0;
00457       _Tp1 _M_t1;
00458       _Tp2 _M_t2;
00459       _Tp3 _M_t3;
00460       _Tp4 _M_t4;
00461 
00462     public:
00463       tuple()
00464       { }
00465 
00466       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
00467              typename __add_c_ref<_Tp1>::type __in1,
00468              typename __add_c_ref<_Tp2>::type __in2,
00469              typename __add_c_ref<_Tp3>::type __in3,
00470              typename __add_c_ref<_Tp4>::type __in4):
00471         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2), _M_t3(__in3), _M_t4(__in4)
00472       { }
00473 
00474       tuple(const tuple& __in):
00475         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
00476         _M_t3(__in._M_t3), _M_t4(__in._M_t4)
00477       { }
00478 
00479       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
00480            typename _Up4>
00481         tuple(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4>& __in):
00482       _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
00483       _M_t3(__in._M_t3), _M_t4(__in._M_t4)
00484         { }
00485 
00486       tuple&
00487       operator=(const tuple& __in)
00488       {
00489         _M_t0=__in._M_t0;
00490         _M_t1=__in._M_t1;
00491         _M_t2=__in._M_t2;
00492         _M_t3=__in._M_t3;
00493         _M_t4=__in._M_t4;
00494         return *this;
00495       }
00496 
00497       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
00498            typename _Up4>
00499         tuple&
00500         operator=(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4>& __in)
00501         {
00502       _M_t0=__in._M_t0;
00503       _M_t1=__in._M_t1;
00504       _M_t2=__in._M_t2;
00505       _M_t3=__in._M_t3;
00506       _M_t4=__in._M_t4;
00507       return *this;
00508         }
00509 
00510       template<int __i, typename _Up>
00511         friend class __get_helper;
00512       template<typename, typename, typename, typename, typename, typename,
00513            typename, typename, typename, typename>
00514         friend class tuple;
00515   };
00516 
00517   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00518        typename _Tp4, typename _Tp5>
00519     class tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _NullClass, _NullClass,
00520             _NullClass, _NullClass>
00521     {
00522       _Tp0 _M_t0;
00523       _Tp1 _M_t1;
00524       _Tp2 _M_t2;
00525       _Tp3 _M_t3;
00526       _Tp4 _M_t4;
00527       _Tp5 _M_t5;
00528 
00529     public:
00530       tuple()
00531       { }
00532 
00533       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
00534              typename __add_c_ref<_Tp1>::type __in1,
00535              typename __add_c_ref<_Tp2>::type __in2,
00536              typename __add_c_ref<_Tp3>::type __in3,
00537              typename __add_c_ref<_Tp4>::type __in4,
00538              typename __add_c_ref<_Tp5>::type __in5):
00539         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2), _M_t3(__in3), _M_t4(__in4),
00540         _M_t5(__in5)
00541       { }
00542 
00543       tuple(const tuple& __in):
00544         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
00545         _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5)
00546       { }
00547 
00548       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
00549            typename _Up4, typename _Up5>
00550         tuple(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5>& __in):
00551       _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
00552       _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5)
00553         { }
00554 
00555       tuple&
00556       operator=(const tuple& __in)
00557       {
00558         _M_t0=__in._M_t0;
00559         _M_t1=__in._M_t1;
00560         _M_t2=__in._M_t2;
00561         _M_t3=__in._M_t3;
00562         _M_t4=__in._M_t4;
00563         _M_t5=__in._M_t5;
00564         return *this;
00565       }
00566 
00567       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
00568            typename _Up4, typename _Up5>
00569         tuple&
00570         operator=(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5>& __in)
00571         {
00572       _M_t0=__in._M_t0;
00573       _M_t1=__in._M_t1;
00574       _M_t2=__in._M_t2;
00575       _M_t3=__in._M_t3;
00576       _M_t4=__in._M_t4;
00577       _M_t5=__in._M_t5;
00578       return *this;
00579         }
00580 
00581       template<int __i, typename _Up>
00582         friend class __get_helper;
00583       template<typename, typename, typename, typename, typename, typename,
00584            typename, typename, typename, typename>
00585         friend class tuple;
00586   };
00587 
00588   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00589        typename _Tp4, typename _Tp5, typename _Tp6>
00590     class tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _NullClass,
00591             _NullClass, _NullClass>
00592     {
00593       _Tp0 _M_t0;
00594       _Tp1 _M_t1;
00595       _Tp2 _M_t2;
00596       _Tp3 _M_t3;
00597       _Tp4 _M_t4;
00598       _Tp5 _M_t5;
00599       _Tp6 _M_t6;
00600 
00601     public:
00602       tuple()
00603       { }
00604 
00605       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
00606              typename __add_c_ref<_Tp1>::type __in1,
00607              typename __add_c_ref<_Tp2>::type __in2,
00608              typename __add_c_ref<_Tp3>::type __in3,
00609              typename __add_c_ref<_Tp4>::type __in4,
00610              typename __add_c_ref<_Tp5>::type __in5,
00611              typename __add_c_ref<_Tp6>::type __in6):
00612         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2), _M_t3(__in3), _M_t4(__in4),
00613         _M_t5(__in5), _M_t6(__in6)
00614       { }
00615 
00616       tuple(const tuple& __in):
00617         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
00618         _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
00619         _M_t6(__in._M_t6)
00620       { }
00621 
00622       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
00623            typename _Up4, typename _Up5, typename _Up6>
00624         tuple(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6>& __in):
00625       _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
00626       _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
00627       _M_t6(__in._M_t6)
00628         { }
00629 
00630       tuple&
00631       operator=(const tuple& __in)
00632       {
00633         _M_t0=__in._M_t0;
00634         _M_t1=__in._M_t1;
00635         _M_t2=__in._M_t2;
00636         _M_t3=__in._M_t3;
00637         _M_t4=__in._M_t4;
00638         _M_t5=__in._M_t5;
00639         _M_t6=__in._M_t6;
00640         return *this;
00641       }
00642 
00643       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
00644            typename _Up4, typename _Up5, typename _Up6>
00645         tuple&
00646         operator=(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5,
00647                   _Up6>& __in)
00648         {
00649       _M_t0=__in._M_t0;
00650       _M_t1=__in._M_t1;
00651       _M_t2=__in._M_t2;
00652       _M_t3=__in._M_t3;
00653       _M_t4=__in._M_t4;
00654       _M_t5=__in._M_t5;
00655       _M_t6=__in._M_t6;
00656       return *this;
00657         }
00658 
00659       template<int __i, typename _Up>
00660         friend class __get_helper;
00661       template<typename, typename, typename, typename, typename, typename,
00662            typename, typename, typename, typename>
00663         friend class tuple;
00664   };
00665 
00666   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00667        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7>
00668     class tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _NullClass,
00669             _NullClass>
00670     {
00671       _Tp0 _M_t0;
00672       _Tp1 _M_t1;
00673       _Tp2 _M_t2;
00674       _Tp3 _M_t3;
00675       _Tp4 _M_t4;
00676       _Tp5 _M_t5;
00677       _Tp6 _M_t6;
00678       _Tp7 _M_t7;
00679 
00680     public:
00681       tuple()
00682       { }
00683 
00684       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
00685              typename __add_c_ref<_Tp1>::type __in1,
00686              typename __add_c_ref<_Tp2>::type __in2,
00687              typename __add_c_ref<_Tp3>::type __in3,
00688              typename __add_c_ref<_Tp4>::type __in4,
00689              typename __add_c_ref<_Tp5>::type __in5,
00690              typename __add_c_ref<_Tp6>::type __in6,
00691              typename __add_c_ref<_Tp7>::type __in7):
00692         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2), _M_t3(__in3), _M_t4(__in4),
00693         _M_t5(__in5), _M_t6(__in6), _M_t7(__in7)
00694       { }
00695 
00696       tuple(const tuple& __in):
00697         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
00698         _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
00699         _M_t6(__in._M_t6), _M_t7(__in._M_t7)
00700       { }
00701 
00702       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
00703            typename _Up4, typename _Up5, typename _Up6, typename _Up7>
00704         tuple(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6,
00705               _Up7>& __in):
00706       _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
00707       _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
00708       _M_t6(__in._M_t6), _M_t7(__in._M_t7)
00709         { }
00710 
00711       tuple&
00712       operator=(const tuple& __in)
00713       {
00714         _M_t0=__in._M_t0;
00715         _M_t1=__in._M_t1;
00716         _M_t2=__in._M_t2;
00717         _M_t3=__in._M_t3;
00718         _M_t4=__in._M_t4;
00719         _M_t5=__in._M_t5;
00720         _M_t6=__in._M_t6;
00721         _M_t7=__in._M_t7;
00722         return *this;
00723       }
00724 
00725       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
00726            typename _Up4, typename _Up5, typename _Up6, typename _Up7>
00727         tuple&
00728         operator=(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6,
00729                   _Up7>& __in)
00730         {
00731       _M_t0=__in._M_t0;
00732       _M_t1=__in._M_t1;
00733       _M_t2=__in._M_t2;
00734       _M_t3=__in._M_t3;
00735       _M_t4=__in._M_t4;
00736       _M_t5=__in._M_t5;
00737       _M_t6=__in._M_t6;
00738       _M_t7=__in._M_t7;
00739       return *this;
00740         }
00741 
00742       template<int __i, typename _Up>
00743         friend class __get_helper;
00744       template<typename, typename, typename, typename, typename, typename,
00745            typename, typename, typename, typename>
00746         friend class tuple;
00747   };
00748 
00749   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00750        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00751        typename _Tp8>
00752     class tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8, 
00753             _NullClass>
00754     {
00755       _Tp0 _M_t0;
00756       _Tp1 _M_t1;
00757       _Tp2 _M_t2;
00758       _Tp3 _M_t3;
00759       _Tp4 _M_t4;
00760       _Tp5 _M_t5;
00761       _Tp6 _M_t6;
00762       _Tp7 _M_t7;
00763       _Tp8 _M_t8;
00764 
00765     public:
00766       tuple()
00767       { }
00768 
00769       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
00770              typename __add_c_ref<_Tp1>::type __in1,
00771              typename __add_c_ref<_Tp2>::type __in2,
00772              typename __add_c_ref<_Tp3>::type __in3,
00773              typename __add_c_ref<_Tp4>::type __in4,
00774              typename __add_c_ref<_Tp5>::type __in5,
00775              typename __add_c_ref<_Tp6>::type __in6,
00776              typename __add_c_ref<_Tp7>::type __in7,
00777              typename __add_c_ref<_Tp8>::type __in8):
00778         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2), _M_t3(__in3), _M_t4(__in4),
00779         _M_t5(__in5), _M_t6(__in6), _M_t7(__in7), _M_t8(__in8)
00780       { }
00781 
00782       tuple(const tuple& __in):
00783         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
00784         _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
00785         _M_t6(__in._M_t6), _M_t7(__in._M_t7), _M_t8(__in._M_t8)
00786       { }
00787 
00788       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
00789            typename _Up4, typename _Up5, typename _Up6, typename _Up7,
00790            typename _Up8>
00791         tuple(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7,
00792               _Up8>& __in):
00793       _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
00794       _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
00795       _M_t6(__in._M_t6), _M_t7(__in._M_t7), _M_t8(__in._M_t8)
00796         { }
00797 
00798       tuple&
00799       operator=(const tuple& __in)
00800       {
00801         _M_t0=__in._M_t0;
00802         _M_t1=__in._M_t1;
00803         _M_t2=__in._M_t2;
00804         _M_t3=__in._M_t3;
00805         _M_t4=__in._M_t4;
00806         _M_t5=__in._M_t5;
00807         _M_t6=__in._M_t6;
00808         _M_t7=__in._M_t7;
00809         _M_t8=__in._M_t8;
00810         return *this;
00811       }
00812 
00813       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
00814            typename _Up4, typename _Up5, typename _Up6, typename _Up7,
00815            typename _Up8>
00816         tuple&
00817         operator=(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7,
00818                   _Up8>& __in)
00819         {
00820       _M_t0=__in._M_t0;
00821       _M_t1=__in._M_t1;
00822       _M_t2=__in._M_t2;
00823       _M_t3=__in._M_t3;
00824       _M_t4=__in._M_t4;
00825       _M_t5=__in._M_t5;
00826       _M_t6=__in._M_t6;
00827       _M_t7=__in._M_t7;
00828       _M_t8=__in._M_t8;
00829       return *this;
00830         }
00831 
00832       template<int __i, typename _Up>
00833         friend class __get_helper;
00834       template<typename, typename, typename, typename, typename, typename,
00835            typename, typename, typename, typename>
00836         friend class tuple;
00837   };
00838 
00839   /// @brief  Template class tuple
00840   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00841        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00842        typename _Tp8, typename _Tp9>
00843     class tuple
00844     {
00845       _Tp0 _M_t0;
00846       _Tp1 _M_t1;
00847       _Tp2 _M_t2;
00848       _Tp3 _M_t3;
00849       _Tp4 _M_t4;
00850       _Tp5 _M_t5;
00851       _Tp6 _M_t6;
00852       _Tp7 _M_t7;
00853       _Tp8 _M_t8;
00854       _Tp9 _M_t9;
00855 
00856     public:
00857       tuple()
00858       { }
00859 
00860       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
00861              typename __add_c_ref<_Tp1>::type __in1,
00862              typename __add_c_ref<_Tp2>::type __in2,
00863              typename __add_c_ref<_Tp3>::type __in3,
00864              typename __add_c_ref<_Tp4>::type __in4,
00865              typename __add_c_ref<_Tp5>::type __in5,
00866              typename __add_c_ref<_Tp6>::type __in6,
00867              typename __add_c_ref<_Tp7>::type __in7,
00868              typename __add_c_ref<_Tp8>::type __in8,
00869              typename __add_c_ref<_Tp9>::type __in9):
00870         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2), _M_t3(__in3), _M_t4(__in4),
00871         _M_t5(__in5), _M_t6(__in6), _M_t7(__in7), _M_t8(__in8), _M_t9(__in9)
00872       { }
00873 
00874       tuple(const tuple& __in):
00875         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
00876         _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
00877         _M_t6(__in._M_t6), _M_t7(__in._M_t7), _M_t8(__in._M_t8),
00878         _M_t9(__in._M_t9)
00879       { }
00880 
00881       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
00882            typename _Up4, typename _Up5, typename _Up6, typename _Up7,
00883            typename _Up8, typename _Up9>
00884         tuple(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8,
00885               _Up9>& __in):
00886       _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
00887       _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
00888       _M_t6(__in._M_t6), _M_t7(__in._M_t7), _M_t8(__in._M_t8),
00889       _M_t9(__in._M_t9)
00890         { }
00891 
00892       tuple&
00893       operator=(const tuple& __in)
00894       {
00895         _M_t0=__in._M_t0;
00896         _M_t1=__in._M_t1;
00897         _M_t2=__in._M_t2;
00898         _M_t3=__in._M_t3;
00899         _M_t4=__in._M_t4;
00900         _M_t5=__in._M_t5;
00901         _M_t6=__in._M_t6;
00902         _M_t7=__in._M_t7;
00903         _M_t8=__in._M_t8;
00904         _M_t9=__in._M_t9;
00905         return *this;
00906       }
00907 
00908       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
00909            typename _Up4, typename _Up5, typename _Up6, typename _Up7,
00910            typename _Up8, typename _Up9>
00911         tuple&
00912         operator=(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7,
00913                   _Up8, _Up9>& __in)
00914         {
00915       _M_t0=__in._M_t0;
00916       _M_t1=__in._M_t1;
00917       _M_t2=__in._M_t2;
00918       _M_t3=__in._M_t3;
00919       _M_t4=__in._M_t4;
00920       _M_t5=__in._M_t5;
00921       _M_t6=__in._M_t6;
00922       _M_t7=__in._M_t7;
00923       _M_t8=__in._M_t8;
00924       _M_t9=__in._M_t9;
00925       return *this;
00926         }
00927 
00928       template<int __i, typename _Up>
00929         friend class __get_helper;
00930       template<typename, typename, typename, typename, typename, typename,
00931            typename, typename, typename, typename>
00932         friend class tuple;
00933   };
00934 
00935   // Class used in the implementation of get
00936   template<int __i, typename _Tp>
00937     struct __get_helper;
00938 
00939   template<typename _Tp>
00940     struct __get_helper<0, _Tp>
00941     {
00942       static typename __add_ref<typename tuple_element<0, _Tp>::type>::type
00943       get_value(_Tp& __in)
00944       { return __in._M_t0; }
00945 
00946       static typename __add_c_ref<typename tuple_element<0, _Tp>::type>::type
00947       get_value(const _Tp& __in)
00948       { return __in._M_t0; }
00949     };
00950 
00951   template<typename _Tp>
00952     struct __get_helper<1, _Tp>
00953     {
00954       static typename __add_ref<typename tuple_element<1, _Tp>::type>::type
00955       get_value(_Tp& __in)
00956       { return __in._M_t1; }
00957 
00958       static typename __add_c_ref<typename tuple_element<1, _Tp>::type>::type
00959       get_value(const _Tp& __in)
00960       { return __in._M_t1; }
00961     };
00962 
00963   template<typename _Tp>
00964     struct __get_helper<2, _Tp>
00965     {
00966       static typename __add_ref<typename tuple_element<2, _Tp>::type>::type
00967       get_value(_Tp& __in)
00968       { return __in._M_t2; }
00969 
00970       static typename __add_c_ref<typename tuple_element<2, _Tp>::type>::type
00971       get_value(const _Tp& __in)
00972       { return __in._M_t2; }
00973     };
00974 
00975   template<typename _Tp>
00976     struct __get_helper<3, _Tp>
00977     {
00978       static typename __add_ref<typename tuple_element<3, _Tp>::type>::type
00979       get_value(_Tp& __in)
00980       { return __in._M_t3; }
00981 
00982       static typename __add_c_ref<typename tuple_element<3, _Tp>::type>::type
00983       get_value(const _Tp& __in)
00984       { return __in._M_t3; }
00985     };
00986 
00987   template<typename _Tp>
00988     struct __get_helper<4, _Tp>
00989     {
00990       static typename __add_ref<typename tuple_element<4, _Tp>::type>::type
00991       get_value(_Tp& __in)
00992       { return __in._M_t4; }
00993 
00994       static typename __add_c_ref<typename tuple_element<4, _Tp>::type>::type
00995       get_value(const _Tp& __in)
00996       { return __in._M_t4; }
00997     };
00998 
00999   template<typename _Tp>
01000     struct __get_helper<5, _Tp>
01001     {
01002       static typename __add_ref<typename tuple_element<5, _Tp>::type>::type
01003       get_value(_Tp& __in)
01004       { return __in._M_t5; }
01005 
01006       static typename __add_c_ref<typename tuple_element<5, _Tp>::type>::type
01007       get_value(const _Tp& __in)
01008       { return __in._M_t5; }
01009     };
01010 
01011   template<typename _Tp>
01012     struct __get_helper<6, _Tp>
01013     {
01014       static typename __add_ref<typename tuple_element<6, _Tp>::type>::type
01015       get_value(_Tp& __in)
01016       { return __in._M_t6; }
01017 
01018       static typename __add_c_ref<typename tuple_element<6, _Tp>::type>::type
01019       get_value(const _Tp& __in)
01020       { return __in._M_t6; }
01021     };
01022 
01023   template<typename _Tp>
01024     struct __get_helper<7, _Tp>
01025     {
01026       static typename __add_ref<typename tuple_element<7, _Tp>::type>::type
01027       get_value(_Tp& __in)
01028       { return __in._M_t7; }
01029 
01030       static typename __add_c_ref<typename tuple_element<7, _Tp>::type>::type
01031       get_value(const _Tp& __in)
01032       { return __in._M_t7; }
01033     };
01034 
01035   template<typename _Tp>
01036     struct __get_helper<8, _Tp>
01037     {
01038       static typename __add_ref<typename tuple_element<8, _Tp>::type>::type
01039       get_value(_Tp& __in)
01040       { return __in._M_t8; }
01041 
01042       static typename __add_c_ref<typename tuple_element<8, _Tp>::type>::type
01043       get_value(const _Tp& __in)
01044       { return __in._M_t8; }
01045     };
01046 
01047   template<typename _Tp>
01048     struct __get_helper<9, _Tp>
01049     {
01050       static typename __add_ref<typename tuple_element<9, _Tp>::type>::type
01051       get_value(_Tp& __in)
01052       { return __in._M_t9; }
01053 
01054       static typename __add_c_ref<typename tuple_element<9, _Tp>::type>::type
01055       get_value(const _Tp& __in)
01056       { return __in._M_t9; }
01057     };
01058 
01059   // Returns a reference to the ith element of a tuple.
01060   // Any const or non-const ref elements are returned with their original type.
01061   template<int __i, typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01062             typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
01063             typename _Tp8, typename _Tp9>
01064     typename __add_ref<typename tuple_element<__i, tuple<_Tp0, _Tp1, _Tp2,
01065                              _Tp3, _Tp4, _Tp5,
01066                              _Tp6, _Tp7, _Tp8,
01067                              _Tp9> >::type>::type
01068     get(tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8,
01069           _Tp9>& __t)
01070     {
01071       return __get_helper<__i, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
01072                      _Tp7, _Tp8, _Tp9> >::get_value(__t);
01073     }
01074 
01075   // Returns a const reference to the ith element of a tuple.
01076   // Any const or non-const ref elements are returned with their original type.
01077   template<int __i, typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01078             typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
01079             typename _Tp8, typename _Tp9>
01080     typename __add_c_ref<typename tuple_element<__i, tuple<_Tp0, _Tp1, _Tp2,
01081                                _Tp3, _Tp4, _Tp5,
01082                                _Tp6, _Tp7, _Tp8,
01083                                _Tp9> >::type>::type
01084     get(const tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8,
01085             _Tp9>& __t)
01086     {
01087       return __get_helper<__i, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
01088                      _Tp7, _Tp8, _Tp9> >::get_value(__t);
01089     }
01090 
01091   // This class helps construct the various comparison operations on tuples
01092   template<int __check_equal_size, int __i, int __j, typename _Tp, typename _Up>
01093     struct __tuple_compare;
01094 
01095   template<int __i, int __j, typename _Tp, typename _Up>
01096     struct __tuple_compare<0, __i, __j, _Tp, _Up>
01097     {
01098       static bool __eq(const _Tp& __t, const _Up& __u)
01099       {
01100         return get<__i>(__t) == get<__i>(__u) &&
01101            __tuple_compare<0, __i+1, __j, _Tp, _Up>::__eq(__t, __u);
01102       }
01103       static bool __less(const _Tp& __t, const _Up& __u)
01104       {
01105         return (get<__i>(__t) < get<__i>(__u)) || !(get<__i>(__u) < get<__i>(__t)) &&
01106            __tuple_compare<0, __i+1, __j, _Tp, _Up>::__less(__t, __u);
01107       }
01108     };
01109 
01110   template<int __i, typename _Tp, typename _Up>
01111     struct __tuple_compare<0, __i, __i, _Tp, _Up>
01112     {
01113       static bool __eq(const _Tp&, const _Up&)
01114       { return true; }
01115       static bool __less(const _Tp&, const _Up&)
01116       { return false; }
01117     };
01118 
01119   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01120        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
01121        typename _Tp8, typename _Tp9, typename _Up0, typename _Up1,
01122        typename _Up2, typename _Up3, typename _Up4, typename _Up5,
01123        typename _Up6, typename _Up7, typename _Up8, typename _Up9>
01124   bool
01125   operator==(const tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8, _Tp9>& __t,
01126          const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8, _Up9>& __u)
01127   {
01128     typedef tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8,
01129           _Tp9> _Tp;
01130     typedef tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8,
01131           _Up9> _Up;
01132     return __tuple_compare<tuple_size<_Tp>::value -
01133      tuple_size<_Tp>::value, 0,
01134       tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u);
01135   }
01136 
01137   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01138        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
01139        typename _Tp8, typename _Tp9, typename _Up0, typename _Up1,
01140        typename _Up2, typename _Up3, typename _Up4, typename _Up5,
01141        typename _Up6, typename _Up7, typename _Up8, typename _Up9>
01142   bool
01143   operator<(const tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8, _Tp9>& __t,
01144         const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8, _Up9>& __u)
01145   {
01146     typedef tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8,
01147           _Tp9> _Tp;
01148     typedef tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8,
01149           _Up9> _Up;
01150     return __tuple_compare<tuple_size<_Tp>::value -
01151      tuple_size<_Tp>::value, 0,
01152       tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u);
01153   }
01154 
01155   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01156        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
01157        typename _Tp8, typename _Tp9, typename _Up0, typename _Up1,
01158        typename _Up2, typename _Up3, typename _Up4, typename _Up5,
01159        typename _Up6, typename _Up7, typename _Up8, typename _Up9>
01160   bool
01161   operator!=(const tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8, _Tp9>& __t,
01162          const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8, _Up9>& __u)
01163   {
01164       return !(__t == __u);
01165   }
01166   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01167        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
01168        typename _Tp8, typename _Tp9, typename _Up0, typename _Up1,
01169        typename _Up2, typename _Up3, typename _Up4, typename _Up5,
01170        typename _Up6, typename _Up7, typename _Up8, typename _Up9>
01171   bool
01172   operator>(const tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8, _Tp9>& __t,
01173         const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8, _Up9>& __u)
01174   {
01175       return __u < __t;
01176   }
01177   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01178        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
01179        typename _Tp8, typename _Tp9, typename _Up0, typename _Up1,
01180        typename _Up2, typename _Up3, typename _Up4, typename _Up5,
01181        typename _Up6, typename _Up7, typename _Up8, typename _Up9>
01182   bool
01183   operator<=(const tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8, _Tp9>& __t,
01184          const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8, _Up9>& __u)
01185   {
01186       return !(__u < __t);
01187   }
01188   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01189        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
01190        typename _Tp8, typename _Tp9, typename _Up0, typename _Up1,
01191        typename _Up2, typename _Up3, typename _Up4, typename _Up5,
01192        typename _Up6, typename _Up7, typename _Up8, typename _Up9>
01193   bool
01194   operator>=(const tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8, _Tp9>& __t,
01195          const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8, _Up9>& __u)
01196   {
01197       return !(__t < __u);
01198   }
01199 
01200   // Helper which adds a reference to a type when given a reference_wrapper
01201   template<typename _Tp>
01202     struct __strip_reference_wrapper
01203     {
01204         typedef _Tp __type;
01205     };
01206 
01207   template<typename _Tp>
01208     struct __strip_reference_wrapper<reference_wrapper<_Tp> >
01209     {
01210       typedef _Tp& __type;
01211     };
01212 
01213   template<typename _Tp>
01214     struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
01215     {
01216         typedef _Tp& __type;
01217     };
01218 
01219   template<typename _Tp0 = _NullClass, typename _Tp1 = _NullClass,
01220        typename _Tp2 = _NullClass, typename _Tp3 = _NullClass,
01221        typename _Tp4 = _NullClass, typename _Tp5 = _NullClass,
01222        typename _Tp6 = _NullClass, typename _Tp7 = _NullClass,
01223        typename _Tp8 = _NullClass, typename _Tp9 = _NullClass>
01224     struct __stripped_tuple_type
01225     {
01226       typedef tuple<typename __strip_reference_wrapper<_Tp0>::__type,
01227             typename __strip_reference_wrapper<_Tp1>::__type,
01228             typename __strip_reference_wrapper<_Tp2>::__type,
01229             typename __strip_reference_wrapper<_Tp3>::__type,
01230             typename __strip_reference_wrapper<_Tp4>::__type,
01231             typename __strip_reference_wrapper<_Tp5>::__type,
01232             typename __strip_reference_wrapper<_Tp6>::__type,
01233             typename __strip_reference_wrapper<_Tp7>::__type,
01234             typename __strip_reference_wrapper<_Tp8>::__type,
01235             typename __strip_reference_wrapper<_Tp9>::__type>      __type;
01236     };
01237 
01238   tuple<>
01239   make_tuple()
01240   { return tuple<>(); }
01241 
01242   template< typename _Tp0>
01243     typename __stripped_tuple_type< _Tp0>::__type
01244     make_tuple( _Tp0 __t0)
01245     {
01246       return typename  __stripped_tuple_type< _Tp0>::
01247         __type( __t0);
01248     }
01249 
01250   template<typename _Tp0, typename _Tp1>
01251     typename __stripped_tuple_type<_Tp0, _Tp1>::__type
01252     make_tuple(_Tp0 __t0, _Tp1 __t1)
01253     {
01254       return typename  __stripped_tuple_type<_Tp0, _Tp1>::
01255         __type(__t0, __t1);
01256     }
01257 
01258   template<typename _Tp0, typename _Tp1, typename _Tp2>
01259     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2>::__type
01260     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2)
01261     {
01262       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2>::
01263         __type(__t0, __t1, __t2);
01264     }
01265 
01266   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3>
01267     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3>::__type
01268     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2, _Tp3 __t3)
01269     {
01270       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3>::
01271         __type(__t0, __t1, __t2, __t3);
01272     }
01273 
01274   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01275        typename _Tp4>
01276     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4>::__type
01277     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2, _Tp3 __t3, _Tp4 __t4)
01278     {
01279       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4>::
01280         __type(__t0, __t1, __t2, __t3, __t4);
01281     }
01282 
01283   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01284        typename _Tp4, typename _Tp5>
01285     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4,
01286                    _Tp5>::__type
01287     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2, _Tp3 __t3, _Tp4 __t4,
01288            _Tp5 __t5)
01289     {
01290       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4,
01291                          _Tp5>::
01292         __type(__t0, __t1, __t2, __t3, __t4, __t5);
01293     }
01294 
01295   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01296        typename _Tp4, typename _Tp5, typename _Tp6>
01297     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5,
01298                    _Tp6>::__type
01299     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2, _Tp3 __t3, _Tp4 __t4,
01300            _Tp5 __t5, _Tp6 __t6)
01301     {
01302       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4,
01303                          _Tp5, _Tp6>::
01304         __type(__t0, __t1, __t2, __t3, __t4, __t5, __t6);
01305     }
01306 
01307   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01308        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7>
01309     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
01310                    _Tp7>::__type
01311     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2, _Tp3 __t3, _Tp4 __t4,
01312            _Tp5 __t5, _Tp6 __t6, _Tp7 __t7)
01313     {
01314       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4,
01315                          _Tp5, _Tp6, _Tp7>::
01316         __type(__t0, __t1, __t2, __t3, __t4, __t5, __t6, __t7);
01317     }
01318 
01319   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01320        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
01321        typename _Tp8>
01322     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
01323                    _Tp7, _Tp8>::__type
01324     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2, _Tp3 __t3, _Tp4 __t4,
01325            _Tp5 __t5, _Tp6 __t6, _Tp7 __t7, _Tp8 __t8)
01326     {
01327       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4,
01328                          _Tp5, _Tp6, _Tp7, _Tp8>::
01329         __type(__t0, __t1, __t2, __t3, __t4, __t5, __t6, __t7, __t8);
01330     }
01331 
01332   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01333        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
01334        typename _Tp8, typename _Tp9>
01335     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
01336                    _Tp7, _Tp8, _Tp9>::__type
01337     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2, _Tp3 __t3, _Tp4 __t4,
01338            _Tp5 __t5, _Tp6 __t6, _Tp7 __t7, _Tp8 __t8, _Tp9 __t9)
01339     {
01340       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4,
01341                          _Tp5, _Tp6, _Tp7, _Tp8, _Tp9>::
01342         __type(__t0, __t1, __t2, __t3, __t4, __t5, __t6, __t7, __t8, __t9);
01343     }
01344 
01345   // A class (and instance) which can be used in 'tie' when an element
01346   // of a tuple is not required
01347   struct swallow_assign
01348   {
01349     template<class T>
01350     swallow_assign&
01351       operator=(const T&)
01352       { return *this; }
01353   };
01354 
01355   // TODO: Put this in some kind of shared file.
01356   namespace
01357   {
01358     swallow_assign ignore;
01359   };
01360 
01361 
01362   // Forms a tuple of references to a list of variables.
01363   template< typename _Tp0>
01364     tuple< _Tp0&>
01365     tie( _Tp0& __t0)
01366     {
01367       return make_tuple( ref(__t0));
01368     };
01369 
01370   template<typename _Tp0, typename _Tp1>
01371     tuple<_Tp0&, _Tp1&>
01372     tie(_Tp0& __t0, _Tp1& __t1)
01373     {
01374       return make_tuple(ref(__t0), ref(__t1));
01375     };
01376 
01377   template<typename _Tp0, typename _Tp1, typename _Tp2>
01378     tuple<_Tp0&, _Tp1&, _Tp2&>
01379     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2)
01380     {
01381       return make_tuple(ref(__t0), ref(__t1), ref(__t2));
01382     };
01383 
01384   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3>
01385     tuple<_Tp0&, _Tp1&, _Tp2&, _Tp3&>
01386     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2, _Tp3& __t3)
01387     {
01388       return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3));
01389     };
01390 
01391   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01392        typename _Tp4>
01393     tuple<_Tp0&, _Tp1&, _Tp2&, _Tp3&, _Tp4&>
01394     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2, _Tp3& __t3, _Tp4& __t4)
01395     {
01396       return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3),
01397                 ref(__t4));
01398     };
01399 
01400   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01401        typename _Tp4, typename _Tp5>
01402     tuple<_Tp0&, _Tp1&, _Tp2&, _Tp3&, _Tp4&, _Tp5&>
01403     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2, _Tp3& __t3, _Tp4& __t4,
01404         _Tp5& __t5)
01405     {
01406       return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3), ref(__t4),
01407                 ref(__t5));
01408     };
01409 
01410   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01411        typename _Tp4, typename _Tp5, typename _Tp6>
01412     tuple<_Tp0&, _Tp1&, _Tp2&, _Tp3&, _Tp4&, _Tp5&, _Tp6&>
01413     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2, _Tp3& __t3, _Tp4& __t4, _Tp5& __t5,
01414         _Tp6& __t6)
01415     {
01416       return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3), ref(__t4),
01417                 ref(__t5), ref(__t6));
01418     };
01419 
01420   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01421        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7>
01422     tuple<_Tp0&, _Tp1&, _Tp2&, _Tp3&, _Tp4&, _Tp5&, _Tp6&, _Tp7&>
01423     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2, _Tp3& __t3, _Tp4& __t4, _Tp5& __t5,
01424         _Tp6& __t6, _Tp7& __t7)
01425     {
01426       return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3), ref(__t4),
01427                 ref(__t5), ref(__t6), ref(__t7));
01428     };
01429 
01430   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01431        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
01432        typename _Tp8>
01433     tuple<_Tp0&, _Tp1&, _Tp2&, _Tp3&, _Tp4&, _Tp5&, _Tp6&, _Tp7&, _Tp8&>
01434     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2, _Tp3& __t3, _Tp4& __t4, _Tp5& __t5,
01435         _Tp6& __t6, _Tp7& __t7, _Tp8& __t8)
01436     {
01437       return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3), ref(__t4),
01438                 ref(__t5), ref(__t6), ref(__t7), ref(__t8));
01439     };
01440 
01441   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
01442        typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
01443        typename _Tp8, typename _Tp9>
01444     tuple<_Tp0&, _Tp1&, _Tp2&, _Tp3&, _Tp4&, _Tp5&, _Tp6&, _Tp7&, _Tp8&,
01445       _Tp9&>
01446     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2, _Tp3& __t3, _Tp4& __t4, _Tp5& __t5,
01447         _Tp6& __t6, _Tp7& __t7, _Tp8& __t8, _Tp9& __t9)
01448     {
01449       return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3), ref(__t4),
01450                 ref(__t5), ref(__t6), ref(__t7), ref(__t8),
01451                 ref(__t9));
01452     };
01453 
01454 }
01455 }
01456 
01457 #endif
01458 

Generated on Sat Apr 2 13:54:44 2005 for libstdc++ source by  doxygen 1.4.0