boost/tuple/detail/tuple_basic_no_partial_spec.hpp

   1 // - tuple_basic_no_partial_spec.hpp -----------------------------------------
   2
   3 // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
   4 // Copyright (C) 2001 Douglas Gregor (gregod@rpi.edu)
   5 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See
   8 // accompanying file LICENSE_1_0.txt or copy at
   9 // http://www.boost.org/LICENSE_1_0.txt)
  10
  11 // For more information, see http://www.boost.org or http://lambda.cs.utu.fi
  12
  13 // Revision History
  14 //  14 02 01    Remove extra ';'. Also, fixed 10-parameter to make_tuple. (DG)
  15 //  10 02 01    Fixed "null_type" constructors.
  16 //              Implemented comparison operators globally.
  17 //              Hide element_type_ref and element_type_const_ref.
  18 //              (DG).
  19 //  09 02 01    Extended to tuples of length 10. Changed comparison for
  20 //              operator<()
  21 //              to the same used by std::pair<>, added cnull_type() (GP)
  22 //  03 02 01    Initial Version from original tuple.hpp code by JJ. (DG)
  23
  24 // -----------------------------------------------------------------
  25
  26 #ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
  27 #define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
  28
  29 #include "boost/type_traits.hpp"
  30 #include <utility>
  31
  32 #if defined BOOST_MSVC
  33 #pragma warning(disable:4518) // storage-class or type specifier(s) unexpected here; ignored
  34 #pragma warning(disable:4181) // qualifier applied to reference type ignored
  35 #pragma warning(disable:4227) // qualifier applied to reference type ignored
  36 #endif
  37
  38 namespace boost {
  39 namespace tuples {
  40
  41     // null_type denotes the end of a list built with "cons"
  42     struct null_type
  43     {
  44       null_type() {}
  45       null_type(const null_type&, const null_type&) {}
  46     };
  47
  48     // a helper function to provide a const null_type type temporary
  49     inline const null_type cnull_type() { return null_type(); }
  50
  51 // forward declaration of tuple
  52     template<
  53       typename T1 = null_type,
  54       typename T2 = null_type,
  55       typename T3 = null_type,
  56       typename T4 = null_type,
  57       typename T5 = null_type,
  58       typename T6 = null_type,
  59       typename T7 = null_type,
  60       typename T8 = null_type,
  61       typename T9 = null_type,
  62       typename T10 = null_type
  63     >
  64     class tuple;
  65
  66 // forward declaration of cons
  67     template<typename Head, typename Tail = null_type>
  68     struct cons;
  69
  70     namespace detail {
  71
  72       // Takes a pointer and routes all assignments to whatever it points to
  73       template<typename T>
  74       struct assign_to_pointee
  75       {
  76       public:
  77         explicit assign_to_pointee(T* p) : ptr(p) {}
  78
  79         template<typename Other>
  80         assign_to_pointee& operator=(const Other& other)
  81         {
  82           *ptr = other;
  83           return *this;
  84         }
  85
  86       private:
  87         T* ptr;
  88       };
  89
  90       // Swallows any assignment
  91       struct swallow_assign
  92       {
  93         template<typename T>
  94         swallow_assign const& operator=(const T&) const
  95         {
  96           return *this;
  97         }
  98       };
  99
 100     template <typename T> struct add_const_reference : add_reference<typename add_const<T>::type> {};
 101
 102     template <class MyTail>
 103     struct init_tail
 104     {
 105         // Each of vc6 and vc7 seem to require a different formulation
 106         // of this return type
 107         template <class H, class T>
 108 #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 109         static typename add_reference<typename add_const<T>::type>::type
 110 #else
 111         static typename add_const_reference<T>::type
 112 #endif
 113         execute( cons<H,T> const& u, long )
 114         {
 115             return u.get_tail();
 116         }
 117     };
 118
 119     template <>
 120     struct init_tail<null_type>
 121     {
 122         template <class H>
 123         static null_type execute( cons<H,null_type> const& u, long )
 124         {
 125             return null_type();
 126         }
 127
 128         template <class U>
 129         static null_type execute(U const&, ...)
 130         {
 131             return null_type();
 132         }
 133      private:
 134         template <class H, class T>
 135         void execute( cons<H,T> const&, int);
 136     };
 137
 138     template <class Other>
 139     Other const&
 140     init_head( Other const& u, ... )
 141     {
 142         return u;
 143     }
 144
 145     template <class H, class T>
 146     typename add_reference<typename add_const<H>::type>::type
 147     init_head( cons<H,T> const& u, int )
 148     {
 149         return u.get_head();
 150     }
 151
 152     inline char**** init_head(null_type const&, int);
 153
 154   } // end of namespace detail
 155
 156     // cons builds a heterogenous list of types
 157    template<typename Head, typename Tail>
 158    struct cons
 159    {
 160      typedef cons self_type;
 161      typedef Head head_type;
 162      typedef Tail tail_type;
 163
 164     private:
 165        typedef typename boost::add_reference<head_type>::type head_ref;
 166        typedef typename boost::add_reference<tail_type>::type tail_ref;
 167        typedef typename detail::add_const_reference<head_type>::type head_cref;
 168        typedef typename detail::add_const_reference<tail_type>::type tail_cref;
 169     public:
 170      head_type head;
 171      tail_type tail;
 172
 173      head_ref get_head() { return head; }
 174      tail_ref get_tail() { return tail; }
 175
 176      head_cref get_head() const { return head; }
 177      tail_cref get_tail() const { return tail; }
 178
 179      cons() : head(), tail() {}
 180
 181 #if defined BOOST_MSVC
 182       template<typename Tail>
 183       cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
 184                     const Tail& t) : head(h), tail(t.head, t.tail)
 185       {
 186       }
 187
 188       cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
 189                     const null_type& t) : head(h), tail(t)
 190       {
 191       }
 192
 193 #else
 194       template<typename T>
 195       explicit cons(head_cref h, const T& t) :
 196         head(h), tail(t.head, t.tail)
 197       {
 198       }
 199
 200       explicit cons(head_cref h = head_type(),
 201                     tail_cref t = tail_type()) :
 202         head(h), tail(t)
 203       {
 204       }
 205 #endif
 206
 207       template <class U>
 208       cons( const U& u )
 209         : head(detail::init_head(u, 0))
 210         , tail(detail::init_tail<Tail>::execute(u, 0L))
 211        {
 212        }
 213
 214       template<typename Other>
 215       cons& operator=(const Other& other)
 216       {
 217         head = other.head;
 218         tail = other.tail;
 219         return *this;
 220       }
 221     };
 222
 223     namespace detail {
 224
 225       // Determines if the parameter is null_type
 226       template<typename T> struct is_null_type { enum { RET = 0 }; };
 227       template<> struct is_null_type<null_type> { enum { RET = 1 }; };
 228
 229       /* Build a cons structure from the given Head and Tail. If both are null_type,
 230       return null_type. */
 231       template<typename Head, typename Tail>
 232       struct build_cons
 233       {
 234       private:
 235         enum { tail_is_null_type = is_null_type<Tail>::RET };
 236       public:
 237         typedef cons<Head, Tail> RET;
 238       };
 239
 240       template<>
 241       struct build_cons<null_type, null_type>
 242       {
 243         typedef null_type RET;
 244       };
 245
 246       // Map the N elements of a tuple into a cons list
 247       template<
 248         typename T1,
 249         typename T2 = null_type,
 250         typename T3 = null_type,
 251         typename T4 = null_type,
 252         typename T5 = null_type,
 253         typename T6 = null_type,
 254         typename T7 = null_type,
 255         typename T8 = null_type,
 256         typename T9 = null_type,
 257         typename T10 = null_type
 258       >
 259       struct map_tuple_to_cons
 260       {
 261         typedef typename detail::build_cons<T10, null_type  >::RET cons10;
 262         typedef typename detail::build_cons<T9, cons10>::RET cons9;
 263         typedef typename detail::build_cons<T8, cons9>::RET cons8;
 264         typedef typename detail::build_cons<T7, cons8>::RET cons7;
 265         typedef typename detail::build_cons<T6, cons7>::RET cons6;
 266         typedef typename detail::build_cons<T5, cons6>::RET cons5;
 267         typedef typename detail::build_cons<T4, cons5>::RET cons4;
 268         typedef typename detail::build_cons<T3, cons4>::RET cons3;
 269         typedef typename detail::build_cons<T2, cons3>::RET cons2;
 270         typedef typename detail::build_cons<T1, cons2>::RET cons1;
 271       };
 272
 273       // Workaround the lack of partial specialization in some compilers
 274       template<int N>
 275       struct _element_type
 276       {
 277         template<typename Tuple>
 278         struct inner
 279         {
 280         private:
 281           typedef typename Tuple::tail_type tail_type;
 282           typedef _element_type<N-1> next_elt_type;
 283
 284         public:
 285           typedef typename _element_type<N-1>::template inner<tail_type>::RET RET;
 286         };
 287       };
 288
 289       template<>
 290       struct _element_type<0>
 291       {
 292         template<typename Tuple>
 293         struct inner
 294         {
 295           typedef typename Tuple::head_type RET;
 296         };
 297       };
 298
 299     } // namespace detail
 300
 301
 302     // Return the Nth type of the given Tuple
 303     template<int N, typename Tuple>
 304     struct element
 305     {
 306     private:
 307       typedef detail::_element_type<N> nth_type;
 308
 309     public:
 310       typedef typename nth_type::template inner<Tuple>::RET RET;
 311       typedef RET type;
 312     };
 313
 314     namespace detail {
 315
 316 #if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
 317       // special workaround for vc7:
 318
 319       template <bool x>
 320       struct reference_adder
 321       {
 322          template <class T>
 323          struct rebind
 324          {
 325             typedef T& type;
 326          };
 327       };
 328
 329       template <>
 330       struct reference_adder<true>
 331       {
 332          template <class T>
 333          struct rebind
 334          {
 335             typedef T type;
 336          };
 337       };
 338
 339
 340       // Return a reference to the Nth type of the given Tuple
 341       template<int N, typename Tuple>
 342       struct element_ref
 343       {
 344       private:
 345          typedef typename element<N, Tuple>::RET elt_type;
 346          enum { is_ref = is_reference<elt_type>::value };
 347
 348       public:
 349          typedef reference_adder<is_ref>::rebind<elt_type>::type RET;
 350          typedef RET type;
 351       };
 352
 353       // Return a const reference to the Nth type of the given Tuple
 354       template<int N, typename Tuple>
 355       struct element_const_ref
 356       {
 357       private:
 358          typedef typename element<N, Tuple>::RET elt_type;
 359          enum { is_ref = is_reference<elt_type>::value };
 360
 361       public:
 362          typedef reference_adder<is_ref>::rebind<const elt_type>::type RET;
 363          typedef RET type;
 364       };
 365
 366 #else // vc7
 367
 368       // Return a reference to the Nth type of the given Tuple
 369       template<int N, typename Tuple>
 370       struct element_ref
 371       {
 372       private:
 373         typedef typename element<N, Tuple>::RET elt_type;
 374
 375       public:
 376         typedef typename add_reference<elt_type>::type RET;
 377         typedef RET type;
 378       };
 379
 380       // Return a const reference to the Nth type of the given Tuple
 381       template<int N, typename Tuple>
 382       struct element_const_ref
 383       {
 384       private:
 385         typedef typename element<N, Tuple>::RET elt_type;
 386
 387       public:
 388         typedef typename add_reference<const elt_type>::type RET;
 389         typedef RET type;
 390       };
 391 #endif // vc7
 392
 393     } // namespace detail
 394
 395     // Get length of this tuple
 396     template<typename Tuple>
 397     struct length
 398     {
 399       BOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
 400     };
 401
 402     template<> struct length<tuple<> > {
 403       BOOST_STATIC_CONSTANT(int, value = 0);
 404     };
 405
 406     template<>
 407     struct length<null_type>
 408     {
 409       BOOST_STATIC_CONSTANT(int, value = 0);
 410     };
 411
 412     namespace detail {
 413
 414     // Reference the Nth element in a tuple and retrieve it with "get"
 415     template<int N>
 416     struct get_class
 417     {
 418       template<typename Head, typename Tail>
 419       static inline
 420       typename detail::element_ref<N, cons<Head, Tail> >::RET
 421       get(cons<Head, Tail>& t)
 422       {
 423         return get_class<N-1>::get(t.tail);
 424       }
 425
 426       template<typename Head, typename Tail>
 427       static inline
 428       typename detail::element_const_ref<N, cons<Head, Tail> >::RET
 429       get(const cons<Head, Tail>& t)
 430       {
 431         return get_class<N-1>::get(t.tail);
 432       }
 433     };
 434
 435     template<>
 436     struct get_class<0>
 437     {
 438       template<typename Head, typename Tail>
 439       static inline
 440       typename add_reference<Head>::type
 441       get(cons<Head, Tail>& t)
 442       {
 443         return t.head;
 444       }
 445
 446       template<typename Head, typename Tail>
 447       static inline
 448       typename add_reference<const Head>::type
 449       get(const cons<Head, Tail>& t)
 450       {
 451         return t.head;
 452       }
 453     };
 454
 455     } // namespace detail
 456
 457     // tuple class
 458     template<
 459       typename T1,
 460       typename T2,
 461       typename T3,
 462       typename T4,
 463       typename T5,
 464       typename T6,
 465       typename T7,
 466       typename T8,
 467       typename T9,
 468       typename T10
 469     >
 470     class tuple :
 471       public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
 472     {
 473     private:
 474       typedef detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> mapped_tuple;
 475       typedef typename mapped_tuple::cons10 cons10;
 476       typedef typename mapped_tuple::cons9 cons9;
 477       typedef typename mapped_tuple::cons8 cons8;
 478       typedef typename mapped_tuple::cons7 cons7;
 479       typedef typename mapped_tuple::cons6 cons6;
 480       typedef typename mapped_tuple::cons5 cons5;
 481       typedef typename mapped_tuple::cons4 cons4;
 482       typedef typename mapped_tuple::cons3 cons3;
 483       typedef typename mapped_tuple::cons2 cons2;
 484       typedef typename mapped_tuple::cons1 cons1;
 485
 486       typedef typename detail::add_const_reference<T1>::type t1_cref;
 487       typedef typename detail::add_const_reference<T2>::type t2_cref;
 488       typedef typename detail::add_const_reference<T3>::type t3_cref;
 489       typedef typename detail::add_const_reference<T4>::type t4_cref;
 490       typedef typename detail::add_const_reference<T5>::type t5_cref;
 491       typedef typename detail::add_const_reference<T6>::type t6_cref;
 492       typedef typename detail::add_const_reference<T7>::type t7_cref;
 493       typedef typename detail::add_const_reference<T8>::type t8_cref;
 494       typedef typename detail::add_const_reference<T9>::type t9_cref;
 495       typedef typename detail::add_const_reference<T10>::type t10_cref;
 496     public:
 497       typedef cons1 inherited;
 498       typedef tuple self_type;
 499
 500       tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
 501         {}
 502
 503       tuple(
 504           t1_cref t1,
 505           t2_cref t2,
 506           t3_cref t3 = T3(),
 507           t4_cref t4 = T4(),
 508           t5_cref t5 = T5(),
 509           t6_cref t6 = T6(),
 510           t7_cref t7 = T7(),
 511           t8_cref t8 = T8(),
 512           t9_cref t9 = T9(),
 513           t10_cref t10 = T10()
 514       ) :
 515         cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
 516       {
 517       }
 518
 519       explicit tuple(t1_cref t1)
 520         : cons1(t1, cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
 521       {}
 522
 523       template<typename Head, typename Tail>
 524       tuple(const cons<Head, Tail>& other) :
 525         cons1(other.head, other.tail)
 526       {
 527       }
 528
 529       template<typename First, typename Second>
 530       self_type& operator=(const std::pair<First, Second>& other)
 531       {
 532         this->head = other.first;
 533         this->tail.head = other.second;
 534         return *this;
 535       }
 536
 537       template<typename Head, typename Tail>
 538       self_type& operator=(const cons<Head, Tail>& other)
 539       {
 540         this->head = other.head;
 541         this->tail = other.tail;
 542
 543         return *this;
 544       }
 545     };
 546
 547     namespace detail {
 548
 549       template<int N> struct workaround_holder {};
 550
 551     } // namespace detail
 552
 553     template<int N, typename Head, typename Tail>
 554     typename detail::element_ref<N, cons<Head, Tail> >::RET
 555     get(cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
 556     {
 557       return detail::get_class<N>::get(t);
 558     }
 559
 560     template<int N, typename Head, typename Tail>
 561     typename detail::element_const_ref<N, cons<Head, Tail> >::RET
 562     get(const cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
 563     {
 564       return detail::get_class<N>::get(t);
 565     }
 566
 567     // Make a tuple
 568     template<typename T1>
 569     inline
 570     tuple<T1>
 571     make_tuple(const T1& t1)
 572     {
 573       return tuple<T1>(t1);
 574     }
 575
 576     // Make a tuple
 577     template<typename T1, typename T2>
 578     inline
 579     tuple<T1, T2>
 580     make_tuple(const T1& t1, const T2& t2)
 581     {
 582       return tuple<T1, T2>(t1, t2);
 583     }
 584
 585     // Make a tuple
 586     template<typename T1, typename T2, typename T3>
 587     inline
 588     tuple<T1, T2, T3>
 589     make_tuple(const T1& t1, const T2& t2, const T3& t3)
 590     {
 591       return tuple<T1, T2, T3>(t1, t2, t3);
 592     }
 593
 594     // Make a tuple
 595     template<typename T1, typename T2, typename T3, typename T4>
 596     inline
 597     tuple<T1, T2, T3, T4>
 598     make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4)
 599     {
 600       return tuple<T1, T2, T3, T4>(t1, t2, t3, t4);
 601     }
 602
 603     // Make a tuple
 604     template<typename T1, typename T2, typename T3, typename T4, typename T5>
 605     inline
 606     tuple<T1, T2, T3, T4, T5>
 607     make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5)
 608     {
 609       return tuple<T1, T2, T3, T4, T5>(t1, t2, t3, t4, t5);
 610     }
 611
 612     // Make a tuple
 613     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
 614     inline
 615     tuple<T1, T2, T3, T4, T5, T6>
 616     make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6)
 617     {
 618       return tuple<T1, T2, T3, T4, T5, T6>(t1, t2, t3, t4, t5, t6);
 619     }
 620
 621     // Make a tuple
 622     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
 623     inline
 624     tuple<T1, T2, T3, T4, T5, T6, T7>
 625     make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7)
 626     {
 627       return tuple<T1, T2, T3, T4, T5, T6, T7>(t1, t2, t3, t4, t5, t6, t7);
 628     }
 629
 630     // Make a tuple
 631     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
 632     inline
 633     tuple<T1, T2, T3, T4, T5, T6, T7, T8>
 634     make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8)
 635     {
 636       return tuple<T1, T2, T3, T4, T5, T6, T7, T8>(t1, t2, t3, t4, t5, t6, t7, t8);
 637     }
 638
 639     // Make a tuple
 640     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
 641     inline
 642     tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
 643     make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9)
 644     {
 645       return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>(t1, t2, t3, t4, t5, t6, t7, t8, t9);
 646     }
 647
 648     // Make a tuple
 649     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
 650     inline
 651     tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
 652     make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10)
 653     {
 654       return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
 655     }
 656
 657     // Tie variables into a tuple
 658     template<typename T1>
 659     inline
 660     tuple<detail::assign_to_pointee<T1> >
 661     tie(T1& t1)
 662     {
 663       return make_tuple(detail::assign_to_pointee<T1>(&t1));
 664     }
 665
 666     // Tie variables into a tuple
 667     template<typename T1, typename T2>
 668     inline
 669     tuple<detail::assign_to_pointee<T1>,
 670       detail::assign_to_pointee<T2> >
 671     tie(T1& t1, T2& t2)
 672     {
 673       return make_tuple(detail::assign_to_pointee<T1>(&t1),
 674                         detail::assign_to_pointee<T2>(&t2));
 675     }
 676
 677     // Tie variables into a tuple
 678     template<typename T1, typename T2, typename T3>
 679     inline
 680     tuple<detail::assign_to_pointee<T1>,
 681       detail::assign_to_pointee<T2>,
 682       detail::assign_to_pointee<T3> >
 683     tie(T1& t1, T2& t2, T3& t3)
 684     {
 685       return make_tuple(detail::assign_to_pointee<T1>(&t1),
 686                         detail::assign_to_pointee<T2>(&t2),
 687                         detail::assign_to_pointee<T3>(&t3));
 688     }
 689
 690     // Tie variables into a tuple
 691     template<typename T1, typename T2, typename T3, typename T4>
 692     inline
 693     tuple<detail::assign_to_pointee<T1>,
 694       detail::assign_to_pointee<T2>,
 695       detail::assign_to_pointee<T3>,
 696       detail::assign_to_pointee<T4> >
 697     tie(T1& t1, T2& t2, T3& t3, T4& t4)
 698     {
 699       return make_tuple(detail::assign_to_pointee<T1>(&t1),
 700                         detail::assign_to_pointee<T2>(&t2),
 701                         detail::assign_to_pointee<T3>(&t3),
 702                         detail::assign_to_pointee<T4>(&t4));
 703     }
 704
 705     // Tie variables into a tuple
 706     template<typename T1, typename T2, typename T3, typename T4, typename T5>
 707     inline
 708     tuple<detail::assign_to_pointee<T1>,
 709       detail::assign_to_pointee<T2>,
 710       detail::assign_to_pointee<T3>,
 711       detail::assign_to_pointee<T4>,
 712       detail::assign_to_pointee<T5> >
 713     tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5)
 714     {
 715       return make_tuple(detail::assign_to_pointee<T1>(&t1),
 716                         detail::assign_to_pointee<T2>(&t2),
 717                         detail::assign_to_pointee<T3>(&t3),
 718                         detail::assign_to_pointee<T4>(&t4),
 719                         detail::assign_to_pointee<T5>(&t5));
 720     }
 721
 722     // Tie variables into a tuple
 723     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
 724     inline
 725     tuple<detail::assign_to_pointee<T1>,
 726       detail::assign_to_pointee<T2>,
 727       detail::assign_to_pointee<T3>,
 728       detail::assign_to_pointee<T4>,
 729       detail::assign_to_pointee<T5>,
 730       detail::assign_to_pointee<T6> >
 731     tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6)
 732     {
 733       return make_tuple(detail::assign_to_pointee<T1>(&t1),
 734                         detail::assign_to_pointee<T2>(&t2),
 735                         detail::assign_to_pointee<T3>(&t3),
 736                         detail::assign_to_pointee<T4>(&t4),
 737                         detail::assign_to_pointee<T5>(&t5),
 738                         detail::assign_to_pointee<T6>(&t6));
 739     }
 740
 741     // Tie variables into a tuple
 742     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
 743     inline
 744     tuple<detail::assign_to_pointee<T1>,
 745       detail::assign_to_pointee<T2>,
 746       detail::assign_to_pointee<T3>,
 747       detail::assign_to_pointee<T4>,
 748       detail::assign_to_pointee<T5>,
 749       detail::assign_to_pointee<T6>,
 750       detail::assign_to_pointee<T7> >
 751     tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7)
 752     {
 753       return make_tuple(detail::assign_to_pointee<T1>(&t1),
 754                         detail::assign_to_pointee<T2>(&t2),
 755                         detail::assign_to_pointee<T3>(&t3),
 756                         detail::assign_to_pointee<T4>(&t4),
 757                         detail::assign_to_pointee<T5>(&t5),
 758                         detail::assign_to_pointee<T6>(&t6),
 759                         detail::assign_to_pointee<T7>(&t7));
 760     }
 761
 762     // Tie variables into a tuple
 763     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
 764     inline
 765     tuple<detail::assign_to_pointee<T1>,
 766       detail::assign_to_pointee<T2>,
 767       detail::assign_to_pointee<T3>,
 768       detail::assign_to_pointee<T4>,
 769       detail::assign_to_pointee<T5>,
 770       detail::assign_to_pointee<T6>,
 771       detail::assign_to_pointee<T7>,
 772       detail::assign_to_pointee<T8> >
 773     tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8)
 774     {
 775       return make_tuple(detail::assign_to_pointee<T1>(&t1),
 776                         detail::assign_to_pointee<T2>(&t2),
 777                         detail::assign_to_pointee<T3>(&t3),
 778                         detail::assign_to_pointee<T4>(&t4),
 779                         detail::assign_to_pointee<T5>(&t5),
 780                         detail::assign_to_pointee<T6>(&t6),
 781                         detail::assign_to_pointee<T7>(&t7),
 782                         detail::assign_to_pointee<T8>(&t8));
 783     }
 784
 785     // Tie variables into a tuple
 786     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
 787     inline
 788     tuple<detail::assign_to_pointee<T1>,
 789       detail::assign_to_pointee<T2>,
 790       detail::assign_to_pointee<T3>,
 791       detail::assign_to_pointee<T4>,
 792       detail::assign_to_pointee<T5>,
 793       detail::assign_to_pointee<T6>,
 794       detail::assign_to_pointee<T7>,
 795       detail::assign_to_pointee<T8>,
 796       detail::assign_to_pointee<T9> >
 797     tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9)
 798     {
 799       return make_tuple(detail::assign_to_pointee<T1>(&t1),
 800                         detail::assign_to_pointee<T2>(&t2),
 801                         detail::assign_to_pointee<T3>(&t3),
 802                         detail::assign_to_pointee<T4>(&t4),
 803                         detail::assign_to_pointee<T5>(&t5),
 804                         detail::assign_to_pointee<T6>(&t6),
 805                         detail::assign_to_pointee<T7>(&t7),
 806                         detail::assign_to_pointee<T8>(&t8),
 807                         detail::assign_to_pointee<T9>(&t9));
 808     }
 809     // Tie variables into a tuple
 810     template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
 811     inline
 812     tuple<detail::assign_to_pointee<T1>,
 813       detail::assign_to_pointee<T2>,
 814       detail::assign_to_pointee<T3>,
 815       detail::assign_to_pointee<T4>,
 816       detail::assign_to_pointee<T5>,
 817       detail::assign_to_pointee<T6>,
 818       detail::assign_to_pointee<T7>,
 819       detail::assign_to_pointee<T8>,
 820       detail::assign_to_pointee<T9>,
 821       detail::assign_to_pointee<T10> >
 822     tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10)
 823     {
 824       return make_tuple(detail::assign_to_pointee<T1>(&t1),
 825                         detail::assign_to_pointee<T2>(&t2),
 826                         detail::assign_to_pointee<T3>(&t3),
 827                         detail::assign_to_pointee<T4>(&t4),
 828                         detail::assign_to_pointee<T5>(&t5),
 829                         detail::assign_to_pointee<T6>(&t6),
 830                         detail::assign_to_pointee<T7>(&t7),
 831                         detail::assign_to_pointee<T8>(&t8),
 832                         detail::assign_to_pointee<T9>(&t9),
 833                         detail::assign_to_pointee<T10>(&t10));
 834     }
 835     // "ignore" allows tuple positions to be ignored when using "tie".
 836
 837 detail::swallow_assign const ignore = detail::swallow_assign();
 838
 839 } // namespace tuples
 840 } // namespace boost
 841 #endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP