boost/boost/tuple/detail/tuple_basic.hpp

   1 //  tuple_basic.hpp -----------------------------------------------------
   2
   3 // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
   4 //
   5 // Permission to copy, use, sell and distribute this software is granted
   6 // provided this copyright notice appears in all copies.
   7 // Permission to modify the code and to distribute modified code is granted
   8 // provided this copyright notice appears in all copies, and a notice
   9 // that the code was modified is included with the copyright notice.
  10 //
  11 // This software is provided "as is" without express or implied warranty,
  12 // and with no claim as to its suitability for any purpose.
  13
  14 // For more information, see http://www.boost.org
  15
  16 // Outside help:
  17 // This and that, Gary Powell.
  18 // Fixed return types for get_head/get_tail
  19 // ( and other bugs ) per suggestion of Jens Maurer
  20 // simplified element type accessors + bug fix  (Jeremy Siek)
  21 // Several changes/additions according to suggestions by Doug Gregor,
  22 // William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes,
  23 // David Abrahams.
  24
  25 // Revision history:
  26 // 2002 05 01 Hugo Duncan: Fix for Borland after Jaakko's previous changes
  27 // 2002 04 18 Jaakko: tuple element types can be void or plain function
  28 //                    types, as long as no object is created.
  29 //                    Tuple objects can no hold even noncopyable types
  30 //                    such as arrays.
  31 // 2001 10 22 John Maddock
  32 //      Fixes for Borland C++
  33 // 2001 08 30 David Abrahams
  34 //      Added default constructor for cons<>.
  35 // -----------------------------------------------------------------
  36
  37 #ifndef BOOST_TUPLE_BASIC_HPP
  38 #define BOOST_TUPLE_BASIC_HPP
  39
  40
  41 #include <utility> // needed for the assignment from pair to tuple
  42
  43 #include "boost/type_traits/cv_traits.hpp"
  44 #include "boost/type_traits/function_traits.hpp"
  45
  46 namespace boost {
  47 namespace tuples {
  48
  49 // -- null_type --------------------------------------------------------
  50 struct null_type {};
  51
  52 // a helper function to provide a const null_type type temporary
  53 namespace detail {
  54   inline const null_type cnull() { return null_type(); }
  55
  56
  57 // -- if construct ------------------------------------------------
  58 // Proposed by Krzysztof Czarnecki and Ulrich Eisenecker
  59
  60 template <bool If, class Then, class Else> struct IF { typedef Then RET; };
  61
  62 template <class Then, class Else> struct IF<false, Then, Else> {
  63   typedef Else RET;
  64 };
  65
  66 } // end detail
  67
  68 // - cons forward declaration -----------------------------------------------
  69 template <class HT, class TT> struct cons;
  70
  71
  72 // - tuple forward declaration -----------------------------------------------
  73 template <
  74   class T0 = null_type, class T1 = null_type, class T2 = null_type,
  75   class T3 = null_type, class T4 = null_type, class T5 = null_type,
  76   class T6 = null_type, class T7 = null_type, class T8 = null_type,
  77   class T9 = null_type>
  78 class tuple;
  79
  80 // tuple_length forward declaration
  81 template<class T> struct length;
  82
  83
  84
  85 namespace detail {
  86
  87 // -- generate error template, referencing to non-existing members of this
  88 // template is used to produce compilation errors intentionally
  89 template<class T>
  90 class generate_error;
  91
  92 // - cons getters --------------------------------------------------------
  93 // called: get_class<N>::get<RETURN_TYPE>(aTuple)
  94
  95 template< int N >
  96 struct get_class {
  97   template<class RET, class HT, class TT >
  98   inline static RET get(const cons<HT, TT>& t)
  99   {
 100     return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
 101   }
 102   template<class RET, class HT, class TT >
 103   inline static RET get(cons<HT, TT>& t)
 104   {
 105     return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
 106   }
 107 };
 108
 109 template<>
 110 struct get_class<0> {
 111   template<class RET, class HT, class TT>
 112   inline static RET get(const cons<HT, TT>& t)
 113   {
 114     return t.head;
 115   }
 116   template<class RET, class HT, class TT>
 117   inline static RET get(cons<HT, TT>& t)
 118   {
 119     return t.head;
 120   }
 121 };
 122
 123 } // end of namespace detail
 124
 125
 126 // -cons type accessors ----------------------------------------
 127 // typename tuples::element<N,T>::type gets the type of the
 128 // Nth element ot T, first element is at index 0
 129 // -------------------------------------------------------
 130
 131 template<int N, class T>
 132 struct element
 133 {
 134 private:
 135   typedef typename T::tail_type Next;
 136 public:
 137   typedef typename element<N-1, Next>::type type;
 138 };
 139 template<class T>
 140 struct element<0,T>
 141 {
 142   typedef typename T::head_type type;
 143 };
 144
 145 template<int N, class T>
 146 struct element<N, const T>
 147 {
 148 private:
 149   typedef typename T::tail_type Next;
 150   typedef typename element<N-1, Next>::type unqualified_type;
 151 public:
 152   typedef typename boost::add_const<unqualified_type>::type type;
 153 };
 154 template<class T>
 155 struct element<0,const T>
 156 {
 157   typedef typename boost::add_const<typename T::head_type>::type type;
 158 };
 159
 160 // -get function templates -----------------------------------------------
 161 // Usage: get<N>(aTuple)
 162
 163 // -- some traits classes for get functions
 164
 165 // access traits lifted from detail namespace to be part of the interface,
 166 // (Joel de Guzman's suggestion). Rationale: get functions are part of the
 167 // interface, so should the way to express their return types be.
 168
 169 template <class T> struct access_traits {
 170   typedef const T& const_type;
 171   typedef T& non_const_type;
 172
 173   typedef const typename boost::remove_cv<T>::type& parameter_type;
 174
 175 // used as the tuple constructors parameter types
 176 // Rationale: non-reference tuple element types can be cv-qualified.
 177 // It should be possible to initialize such types with temporaries,
 178 // and when binding temporaries to references, the reference must
 179 // be non-volatile and const. 8.5.3. (5)
 180 };
 181
 182 template <class T> struct access_traits<T&> {
 183
 184   typedef T& const_type;
 185   typedef T& non_const_type;
 186
 187   typedef T& parameter_type;
 188 };
 189
 190 // get function for non-const cons-lists, returns a reference to the element
 191
 192 template<int N, class HT, class TT>
 193 inline typename access_traits<
 194                   typename element<N, cons<HT, TT> >::type
 195                 >::non_const_type
 196 get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
 197   return detail::get_class<N>::BOOST_NESTED_TEMPLATE
 198          get<
 199            typename access_traits<
 200              typename element<N, cons<HT, TT> >::type
 201            >::non_const_type>(c);
 202 }
 203
 204 // get function for const cons-lists, returns a const reference to
 205 // the element. If the element is a reference, returns the reference
 206 // as such (that is, can return a non-const reference)
 207 template<int N, class HT, class TT>
 208 inline typename access_traits<
 209                   typename element<N, cons<HT, TT> >::type
 210                 >::const_type
 211 get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
 212   return detail::get_class<N>::BOOST_NESTED_TEMPLATE
 213          get<
 214            typename access_traits<
 215              typename element<N, cons<HT, TT> >::type
 216          >::const_type>(c);
 217 }
 218
 219 // -- the cons template  --------------------------------------------------
 220 namespace detail {
 221
 222 //  These helper templates wrap void types and plain function types.
 223 //  The reationale is to allow one to write tuple types with those types
 224 //  as elements, even though it is not possible to instantiate such object.
 225 //  E.g: typedef tuple<void> some_type; // ok
 226 //  but: some_type x; // fails
 227
 228 template <class T> class non_storeable_type {
 229   non_storeable_type();
 230 };
 231
 232 template <class T> struct wrap_non_storeable_type {
 233   typedef typename IF<
 234     ::boost::is_function<T>::value, non_storeable_type<T>, T
 235   >::RET type;
 236 };
 237 template <> struct wrap_non_storeable_type<void> {
 238   typedef non_storeable_type<void> type;
 239 };
 240
 241 } // detail
 242
 243 template <class HT, class TT>
 244 struct cons {
 245
 246   typedef HT head_type;
 247   typedef TT tail_type;
 248
 249   typedef typename
 250     detail::wrap_non_storeable_type<head_type>::type stored_head_type;
 251
 252   stored_head_type head;
 253   tail_type tail;
 254
 255   typename access_traits<stored_head_type>::non_const_type
 256   get_head() { return head; }
 257
 258   typename access_traits<tail_type>::non_const_type
 259   get_tail() { return tail; }
 260
 261   typename access_traits<stored_head_type>::const_type
 262   get_head() const { return head; }
 263
 264   typename access_traits<tail_type>::const_type
 265   get_tail() const { return tail; }
 266
 267   cons() : head(), tail() {}
 268   //  cons() : head(detail::default_arg<HT>::f()), tail() {}
 269
 270   // the argument for head is not strictly needed, but it prevents
 271   // array type elements. This is good, since array type elements
 272   // cannot be supported properly in any case (no assignment,
 273   // copy works only if the tails are exactly the same type, ...)
 274
 275   cons(typename access_traits<stored_head_type>::parameter_type h,
 276        const tail_type& t)
 277     : head (h), tail(t) {}
 278
 279   template <class T1, class T2, class T3, class T4, class T5,
 280             class T6, class T7, class T8, class T9, class T10>
 281   cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
 282         T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
 283     : head (t1),
 284       tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
 285       {}
 286
 287   template <class T2, class T3, class T4, class T5,
 288             class T6, class T7, class T8, class T9, class T10>
 289   cons( const null_type& t1, T2& t2, T3& t3, T4& t4, T5& t5,
 290         T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
 291     : head (),
 292       tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
 293       {}
 294
 295
 296   template <class HT2, class TT2>
 297   cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}
 298
 299   template <class HT2, class TT2>
 300   cons& operator=( const cons<HT2, TT2>& u ) {
 301     head=u.head; tail=u.tail; return *this;
 302   }
 303
 304   // must define assignment operator explicitly, implicit version is
 305   // illformed if HT is a reference (12.8. (12))
 306   cons& operator=(const cons& u) {
 307     head = u.head; tail = u.tail;  return *this;
 308   }
 309
 310   template <class T1, class T2>
 311   cons& operator=( const std::pair<T1, T2>& u ) {
 312     BOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2
 313     head = u.first; tail.head = u.second; return *this;
 314   }
 315
 316   // get member functions (non-const and const)
 317   template <int N>
 318   typename access_traits<
 319              typename element<N, cons<HT, TT> >::type
 320            >::non_const_type
 321   get() {
 322     return boost::tuples::get<N>(*this); // delegate to non-member get
 323   }
 324
 325   template <int N>
 326   typename access_traits<
 327              typename element<N, cons<HT, TT> >::type
 328            >::const_type
 329   get() const {
 330     return boost::tuples::get<N>(*this); // delegate to non-member get
 331   }
 332 };
 333
 334 template <class HT>
 335 struct cons<HT, null_type> {
 336
 337   typedef HT head_type;
 338   typedef null_type tail_type;
 339   typedef cons<HT, null_type> self_type;
 340
 341   typedef typename
 342     detail::wrap_non_storeable_type<head_type>::type stored_head_type;
 343   stored_head_type head;
 344
 345   typename access_traits<stored_head_type>::non_const_type
 346   get_head() { return head; }
 347
 348   null_type get_tail() { return null_type(); }
 349
 350   typename access_traits<stored_head_type>::const_type
 351   get_head() const { return head; }
 352
 353   const null_type get_tail() const { return null_type(); }
 354
 355   //  cons() : head(detail::default_arg<HT>::f()) {}
 356   cons() : head() {}
 357
 358   cons(typename access_traits<stored_head_type>::parameter_type h,
 359        const null_type& = null_type())
 360     : head (h) {}
 361
 362   template<class T1>
 363   cons(T1& t1, const null_type&, const null_type&, const null_type&,
 364        const null_type&, const null_type&, const null_type&,
 365        const null_type&, const null_type&, const null_type&)
 366   : head (t1) {}
 367
 368   cons(const null_type&,
 369        const null_type&, const null_type&, const null_type&,
 370        const null_type&, const null_type&, const null_type&,
 371        const null_type&, const null_type&, const null_type&)
 372   : head () {}
 373
 374   template <class HT2>
 375   cons( const cons<HT2, null_type>& u ) : head(u.head) {}
 376
 377   template <class HT2>
 378   cons& operator=(const cons<HT2, null_type>& u )
 379   { head = u.head; return *this; }
 380
 381   // must define assignment operator explicitely, implicit version
 382   // is illformed if HT is a reference
 383   cons& operator=(const cons& u) { head = u.head; return *this; }
 384
 385   template <int N>
 386   typename access_traits<
 387              typename element<N, self_type>::type
 388             >::non_const_type
 389   get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
 390     return boost::tuples::get<N>(*this);
 391   }
 392
 393   template <int N>
 394   typename access_traits<
 395              typename element<N, self_type>::type
 396            >::const_type
 397   get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const {
 398     return boost::tuples::get<N>(*this);
 399   }
 400
 401 };
 402
 403 // templates for finding out the length of the tuple -------------------
 404
 405 template<class T>
 406 struct length  {
 407   BOOST_STATIC_CONSTANT(int, value = 1 + length<typename T::tail_type>::value);
 408 };
 409
 410 template<>
 411 struct length<tuple<> > {
 412   BOOST_STATIC_CONSTANT(int, value = 0);
 413 };
 414
 415 template<>
 416 struct length<null_type> {
 417   BOOST_STATIC_CONSTANT(int, value = 0);
 418 };
 419
 420
 421 namespace detail {
 422
 423 // Tuple to cons mapper --------------------------------------------------
 424 template <class T0, class T1, class T2, class T3, class T4,
 425           class T5, class T6, class T7, class T8, class T9>
 426 struct map_tuple_to_cons
 427 {
 428   typedef cons<T0,
 429                typename map_tuple_to_cons<T1, T2, T3, T4, T5,
 430                                           T6, T7, T8, T9, null_type>::type
 431               > type;
 432 };
 433
 434 // The empty tuple is a null_type
 435 template <>
 436 struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>
 437 {
 438   typedef null_type type;
 439 };
 440
 441 } // end detail
 442
 443 // -------------------------------------------------------------------
 444 // -- tuple ------------------------------------------------------
 445 template <class T0, class T1, class T2, class T3, class T4,
 446           class T5, class T6, class T7, class T8, class T9>
 447
 448 class tuple :
 449   public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
 450 {
 451 public:
 452   typedef typename
 453     detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
 454   typedef typename inherited::head_type head_type;
 455   typedef typename inherited::tail_type tail_type;
 456
 457
 458 // access_traits<T>::parameter_type takes non-reference types as const T&
 459   tuple() {}
 460
 461   tuple(typename access_traits<T0>::parameter_type t0)
 462     : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
 463                 detail::cnull(), detail::cnull(), detail::cnull(),
 464                 detail::cnull(), detail::cnull(), detail::cnull()) {}
 465
 466   tuple(typename access_traits<T0>::parameter_type t0,
 467         typename access_traits<T1>::parameter_type t1)
 468     : inherited(t0, t1, detail::cnull(), detail::cnull(),
 469                 detail::cnull(), detail::cnull(), detail::cnull(),
 470                 detail::cnull(), detail::cnull(), detail::cnull()) {}
 471
 472   tuple(typename access_traits<T0>::parameter_type t0,
 473         typename access_traits<T1>::parameter_type t1,
 474         typename access_traits<T2>::parameter_type t2)
 475     : inherited(t0, t1, t2, detail::cnull(), detail::cnull(),
 476                 detail::cnull(), detail::cnull(), detail::cnull(),
 477                 detail::cnull(), detail::cnull()) {}
 478
 479   tuple(typename access_traits<T0>::parameter_type t0,
 480         typename access_traits<T1>::parameter_type t1,
 481         typename access_traits<T2>::parameter_type t2,
 482         typename access_traits<T3>::parameter_type t3)
 483     : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),
 484                 detail::cnull(), detail::cnull(), detail::cnull(),
 485                 detail::cnull()) {}
 486
 487   tuple(typename access_traits<T0>::parameter_type t0,
 488         typename access_traits<T1>::parameter_type t1,
 489         typename access_traits<T2>::parameter_type t2,
 490         typename access_traits<T3>::parameter_type t3,
 491         typename access_traits<T4>::parameter_type t4)
 492     : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),
 493                 detail::cnull(), detail::cnull(), detail::cnull()) {}
 494
 495   tuple(typename access_traits<T0>::parameter_type t0,
 496         typename access_traits<T1>::parameter_type t1,
 497         typename access_traits<T2>::parameter_type t2,
 498         typename access_traits<T3>::parameter_type t3,
 499         typename access_traits<T4>::parameter_type t4,
 500         typename access_traits<T5>::parameter_type t5)
 501     : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),
 502                 detail::cnull(), detail::cnull()) {}
 503
 504   tuple(typename access_traits<T0>::parameter_type t0,
 505         typename access_traits<T1>::parameter_type t1,
 506         typename access_traits<T2>::parameter_type t2,
 507         typename access_traits<T3>::parameter_type t3,
 508         typename access_traits<T4>::parameter_type t4,
 509         typename access_traits<T5>::parameter_type t5,
 510         typename access_traits<T6>::parameter_type t6)
 511     : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),
 512                 detail::cnull(), detail::cnull()) {}
 513
 514   tuple(typename access_traits<T0>::parameter_type t0,
 515         typename access_traits<T1>::parameter_type t1,
 516         typename access_traits<T2>::parameter_type t2,
 517         typename access_traits<T3>::parameter_type t3,
 518         typename access_traits<T4>::parameter_type t4,
 519         typename access_traits<T5>::parameter_type t5,
 520         typename access_traits<T6>::parameter_type t6,
 521         typename access_traits<T7>::parameter_type t7)
 522     : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),
 523                 detail::cnull()) {}
 524
 525   tuple(typename access_traits<T0>::parameter_type t0,
 526         typename access_traits<T1>::parameter_type t1,
 527         typename access_traits<T2>::parameter_type t2,
 528         typename access_traits<T3>::parameter_type t3,
 529         typename access_traits<T4>::parameter_type t4,
 530         typename access_traits<T5>::parameter_type t5,
 531         typename access_traits<T6>::parameter_type t6,
 532         typename access_traits<T7>::parameter_type t7,
 533         typename access_traits<T8>::parameter_type t8)
 534     : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {}
 535
 536   tuple(typename access_traits<T0>::parameter_type t0,
 537         typename access_traits<T1>::parameter_type t1,
 538         typename access_traits<T2>::parameter_type t2,
 539         typename access_traits<T3>::parameter_type t3,
 540         typename access_traits<T4>::parameter_type t4,
 541         typename access_traits<T5>::parameter_type t5,
 542         typename access_traits<T6>::parameter_type t6,
 543         typename access_traits<T7>::parameter_type t7,
 544         typename access_traits<T8>::parameter_type t8,
 545         typename access_traits<T9>::parameter_type t9)
 546     : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
 547
 548
 549   template<class U1, class U2>
 550   tuple(const cons<U1, U2>& p) : inherited(p) {}
 551
 552   template <class U1, class U2>
 553   tuple& operator=(const cons<U1, U2>& k) {
 554     inherited::operator=(k);
 555     return *this;
 556   }
 557
 558   template <class U1, class U2>
 559   tuple& operator=(const std::pair<U1, U2>& k) {
 560     BOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2
 561     this->head = k.first;
 562     this->tail.head = k.second;
 563     return *this;
 564   }
 565
 566 };
 567
 568 // The empty tuple
 569 template <>
 570 class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>  :
 571   public null_type
 572 {
 573 public:
 574   typedef null_type inherited;
 575 };
 576
 577
 578 // Swallows any assignment   (by Doug Gregor)
 579 namespace detail {
 580
 581 struct swallow_assign {
 582
 583   template<typename T>
 584   swallow_assign const& operator=(const T&) const {
 585     return *this;
 586   }
 587 };
 588
 589 } // namespace detail
 590
 591 // "ignore" allows tuple positions to be ignored when using "tie".
 592 detail::swallow_assign const ignore = detail::swallow_assign();
 593
 594 // ---------------------------------------------------------------------------
 595 // The call_traits for make_tuple
 596 // Honours the reference_wrapper class.
 597
 598 // Must be instantiated with plain or const plain types (not with references)
 599
 600 // from template<class T> foo(const T& t) : make_tuple_traits<const T>::type
 601 // from template<class T> foo(T& t) : make_tuple_traits<T>::type
 602
 603 // Conversions:
 604 // T -> T,
 605 // references -> compile_time_error
 606 // reference_wrapper<T> -> T&
 607 // const reference_wrapper<T> -> T&
 608 // array -> const ref array
 609
 610
 611 template<class T>
 612 struct make_tuple_traits {
 613   typedef T type;
 614
 615   // commented away, see below  (JJ)
 616   //  typedef typename IF<
 617   //  boost::is_function<T>::value,
 618   //  T&,
 619   //  T>::RET type;
 620
 621 };
 622
 623 // The is_function test was there originally for plain function types,
 624 // which can't be stored as such (we must either store them as references or
 625 // pointers). Such a type could be formed if make_tuple was called with a
 626 // reference to a function.
 627 // But this would mean that a const qualified function type was formed in
 628 // the make_tuple function and hence make_tuple can't take a function
 629 // reference as a parameter, and thus T can't be a function type.
 630 // So is_function test was removed.
 631 // (14.8.3. says that type deduction fails if a cv-qualified function type
 632 // is created. (It only applies for the case of explicitly specifying template
 633 // args, though?)) (JJ)
 634
 635 template<class T>
 636 struct make_tuple_traits<T&> {
 637   typedef typename
 638      detail::generate_error<T&>::
 639        do_not_use_with_reference_type error;
 640 };
 641
 642 // Arrays can't be stored as plain types; convert them to references.
 643 // All arrays are converted to const. This is because make_tuple takes its
 644 // parameters as const T& and thus the knowledge of the potential
 645 // non-constness of actual argument is lost.
 646 template<class T, int n>  struct make_tuple_traits <T[n]> {
 647   typedef const T (&type)[n];
 648 };
 649
 650 template<class T, int n>
 651 struct make_tuple_traits<const T[n]> {
 652   typedef const T (&type)[n];
 653 };
 654
 655 template<class T, int n>  struct make_tuple_traits<volatile T[n]> {
 656   typedef const volatile T (&type)[n];
 657 };
 658
 659 template<class T, int n>
 660 struct make_tuple_traits<const volatile T[n]> {
 661   typedef const volatile T (&type)[n];
 662 };
 663
 664 template<class T>
 665 struct make_tuple_traits<reference_wrapper<T> >{
 666   typedef T& type;
 667 };
 668
 669 template<class T>
 670 struct make_tuple_traits<const reference_wrapper<T> >{
 671   typedef T& type;
 672 };
 673
 674
 675
 676
 677 namespace detail {
 678
 679 // a helper traits to make the make_tuple functions shorter (Vesa Karvonen's
 680 // suggestion)
 681 template <
 682   class T0 = null_type, class T1 = null_type, class T2 = null_type,
 683   class T3 = null_type, class T4 = null_type, class T5 = null_type,
 684   class T6 = null_type, class T7 = null_type, class T8 = null_type,
 685   class T9 = null_type
 686 >
 687 struct make_tuple_mapper {
 688   typedef
 689     tuple<typename make_tuple_traits<T0>::type,
 690           typename make_tuple_traits<T1>::type,
 691           typename make_tuple_traits<T2>::type,
 692           typename make_tuple_traits<T3>::type,
 693           typename make_tuple_traits<T4>::type,
 694           typename make_tuple_traits<T5>::type,
 695           typename make_tuple_traits<T6>::type,
 696           typename make_tuple_traits<T7>::type,
 697           typename make_tuple_traits<T8>::type,
 698           typename make_tuple_traits<T9>::type> type;
 699 };
 700
 701 } // end detail
 702
 703 // -make_tuple function templates -----------------------------------
 704 inline tuple<> make_tuple() {
 705   return tuple<>();
 706 }
 707
 708 template<class T0>
 709 inline typename detail::make_tuple_mapper<T0>::type
 710 make_tuple(const T0& t0) {
 711   typedef typename detail::make_tuple_mapper<T0>::type t;
 712   return t(t0);
 713 }
 714
 715 template<class T0, class T1>
 716 inline typename detail::make_tuple_mapper<T0, T1>::type
 717 make_tuple(const T0& t0, const T1& t1) {
 718   typedef typename detail::make_tuple_mapper<T0, T1>::type t;
 719   return t(t0, t1);
 720 }
 721
 722 template<class T0, class T1, class T2>
 723 inline typename detail::make_tuple_mapper<T0, T1, T2>::type
 724 make_tuple(const T0& t0, const T1& t1, const T2& t2) {
 725   typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t;
 726   return t(t0, t1, t2);
 727 }
 728
 729 template<class T0, class T1, class T2, class T3>
 730 inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
 731 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
 732   typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t;
 733   return t(t0, t1, t2, t3);
 734 }
 735
 736 template<class T0, class T1, class T2, class T3, class T4>
 737 inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
 738 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
 739                   const T4& t4) {
 740   typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
 741   return t(t0, t1, t2, t3, t4);
 742 }
 743
 744 template<class T0, class T1, class T2, class T3, class T4, class T5>
 745 inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
 746 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
 747                   const T4& t4, const T5& t5) {
 748   typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
 749   return t(t0, t1, t2, t3, t4, t5);
 750 }
 751
 752 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
 753 inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
 754 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
 755                   const T4& t4, const T5& t5, const T6& t6) {
 756   typedef typename detail::make_tuple_mapper
 757            <T0, T1, T2, T3, T4, T5, T6>::type t;
 758   return t(t0, t1, t2, t3, t4, t5, t6);
 759 }
 760
 761 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
 762          class T7>
 763 inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
 764 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
 765                   const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
 766   typedef typename detail::make_tuple_mapper
 767            <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
 768   return t(t0, t1, t2, t3, t4, t5, t6, t7);
 769 }
 770
 771 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
 772          class T7, class T8>
 773 inline typename detail::make_tuple_mapper
 774   <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
 775 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
 776                   const T4& t4, const T5& t5, const T6& t6, const T7& t7,
 777                   const T8& t8) {
 778   typedef typename detail::make_tuple_mapper
 779            <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
 780   return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
 781 }
 782
 783 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
 784          class T7, class T8, class T9>
 785 inline typename detail::make_tuple_mapper
 786   <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
 787 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
 788                   const T4& t4, const T5& t5, const T6& t6, const T7& t7,
 789                   const T8& t8, const T9& t9) {
 790   typedef typename detail::make_tuple_mapper
 791            <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
 792   return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
 793 }
 794
 795
 796
 797 // Tie function templates -------------------------------------------------
 798 template<class T1>
 799 inline tuple<T1&> tie(T1& t1) {
 800   return tuple<T1&> (t1);
 801 }
 802
 803 template<class T1, class T2>
 804 inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {
 805   return tuple<T1&, T2&> (t1, t2);
 806 }
 807
 808 template<class T1, class T2, class T3>
 809 inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {
 810   return tuple<T1&, T2&, T3&> (t1, t2, t3);
 811 }
 812
 813 template<class T1, class T2, class T3, class T4>
 814 inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
 815   return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);
 816 }
 817
 818 template<class T1, class T2, class T3, class T4, class T5>
 819 inline tuple<T1&, T2&, T3&, T4&, T5&>
 820 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
 821   return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
 822 }
 823
 824 template<class T1, class T2, class T3, class T4, class T5, class T6>
 825 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
 826 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
 827   return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
 828 }
 829
 830 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
 831 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
 832 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
 833   return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
 834 }
 835
 836 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
 837          class T8>
 838 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
 839 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
 840   return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
 841            (t1, t2, t3, t4, t5, t6, t7, t8);
 842 }
 843
 844 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
 845          class T8, class T9>
 846 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
 847 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
 848            T9& t9) {
 849   return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
 850             (t1, t2, t3, t4, t5, t6, t7, t8, t9);
 851 }
 852
 853 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
 854          class T8, class T9, class T10>
 855 inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
 856 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
 857            T9& t9, T10& t10) {
 858   return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
 859            (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
 860 }
 861
 862 } // end of namespace tuples
 863 } // end of namespace boost
 864
 865
 866 #endif // BOOST_TUPLE_BASIC_HPP
 867
 868