1 // - tuple_basic_no_partial_spec.hpp -----------------------------------------
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)
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)
11 // For more information, see http://www.boost.org or http://lambda.cs.utu.fi
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.
19 // 09 02 01 Extended to tuples of length 10. Changed comparison for
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)
24 // -----------------------------------------------------------------
26 #ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
27 #define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
29 #include "boost/type_traits.hpp"
30 #include "boost/utility/swap.hpp"
33 #if defined BOOST_MSVC
34 #pragma warning(disable:4518) // storage-class or type specifier(s) unexpected here; ignored
35 #pragma warning(disable:4181) // qualifier applied to reference type ignored
36 #pragma warning(disable:4227) // qualifier applied to reference type ignored
42 // null_type denotes the end of a list built with "cons"
46 null_type(const null_type&, const null_type&) {}
49 // a helper function to provide a const null_type type temporary
50 inline const null_type cnull_type() { return null_type(); }
52 // forward declaration of tuple
54 typename T1 = null_type,
55 typename T2 = null_type,
56 typename T3 = null_type,
57 typename T4 = null_type,
58 typename T5 = null_type,
59 typename T6 = null_type,
60 typename T7 = null_type,
61 typename T8 = null_type,
62 typename T9 = null_type,
63 typename T10 = null_type
67 // forward declaration of cons
68 template<typename Head, typename Tail = null_type>
73 // Takes a pointer and routes all assignments to whatever it points to
75 struct assign_to_pointee
78 explicit assign_to_pointee(T* p) : ptr(p) {}
80 template<typename Other>
81 assign_to_pointee& operator=(const Other& other)
91 // Swallows any assignment
95 swallow_assign const& operator=(const T&) const
101 template <typename T> struct add_const_reference : add_reference<typename add_const<T>::type> {};
103 template <class MyTail>
106 // Each of vc6 and vc7 seem to require a different formulation
107 // of this return type
108 template <class H, class T>
109 #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
110 static typename add_reference<typename add_const<T>::type>::type
112 static typename add_const_reference<T>::type
114 execute( cons<H,T> const& u, long )
121 struct init_tail<null_type>
124 static null_type execute( cons<H,null_type> const& u, long )
130 static null_type execute(U const&, ...)
135 template <class H, class T>
136 void execute( cons<H,T> const&, int);
139 template <class Other>
141 init_head( Other const& u, ... )
146 template <class H, class T>
147 typename add_reference<typename add_const<H>::type>::type
148 init_head( cons<H,T> const& u, int )
153 inline char**** init_head(null_type const&, int);
155 } // end of namespace detail
157 // cons builds a heterogenous list of types
158 template<typename Head, typename Tail>
161 typedef cons self_type;
162 typedef Head head_type;
163 typedef Tail tail_type;
166 typedef typename boost::add_reference<head_type>::type head_ref;
167 typedef typename boost::add_reference<tail_type>::type tail_ref;
168 typedef typename detail::add_const_reference<head_type>::type head_cref;
169 typedef typename detail::add_const_reference<tail_type>::type tail_cref;
174 head_ref get_head() { return head; }
175 tail_ref get_tail() { return tail; }
177 head_cref get_head() const { return head; }
178 tail_cref get_tail() const { return tail; }
180 cons() : head(), tail() {}
182 #if defined BOOST_MSVC
183 template<typename Tail>
184 cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
185 const Tail& t) : head(h), tail(t.head, t.tail)
189 cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
190 const null_type& t) : head(h), tail(t)
196 explicit cons(head_cref h, const T& t) :
197 head(h), tail(t.head, t.tail)
201 explicit cons(head_cref h = head_type(),
202 tail_cref t = tail_type()) :
210 : head(detail::init_head(u, 0))
211 , tail(detail::init_tail<Tail>::execute(u, 0L))
215 template<typename Other>
216 cons& operator=(const Other& other)
226 // Determines if the parameter is null_type
227 template<typename T> struct is_null_type { enum { RET = 0 }; };
228 template<> struct is_null_type<null_type> { enum { RET = 1 }; };
230 /* Build a cons structure from the given Head and Tail. If both are null_type,
232 template<typename Head, typename Tail>
236 enum { tail_is_null_type = is_null_type<Tail>::RET };
238 typedef cons<Head, Tail> RET;
242 struct build_cons<null_type, null_type>
244 typedef null_type RET;
247 // Map the N elements of a tuple into a cons list
250 typename T2 = null_type,
251 typename T3 = null_type,
252 typename T4 = null_type,
253 typename T5 = null_type,
254 typename T6 = null_type,
255 typename T7 = null_type,
256 typename T8 = null_type,
257 typename T9 = null_type,
258 typename T10 = null_type
260 struct map_tuple_to_cons
262 typedef typename detail::build_cons<T10, null_type >::RET cons10;
263 typedef typename detail::build_cons<T9, cons10>::RET cons9;
264 typedef typename detail::build_cons<T8, cons9>::RET cons8;
265 typedef typename detail::build_cons<T7, cons8>::RET cons7;
266 typedef typename detail::build_cons<T6, cons7>::RET cons6;
267 typedef typename detail::build_cons<T5, cons6>::RET cons5;
268 typedef typename detail::build_cons<T4, cons5>::RET cons4;
269 typedef typename detail::build_cons<T3, cons4>::RET cons3;
270 typedef typename detail::build_cons<T2, cons3>::RET cons2;
271 typedef typename detail::build_cons<T1, cons2>::RET cons1;
274 // Workaround the lack of partial specialization in some compilers
278 template<typename Tuple>
282 typedef typename Tuple::tail_type tail_type;
283 typedef _element_type<N-1> next_elt_type;
286 typedef typename _element_type<N-1>::template inner<tail_type>::RET RET;
291 struct _element_type<0>
293 template<typename Tuple>
296 typedef typename Tuple::head_type RET;
300 } // namespace detail
303 // Return the Nth type of the given Tuple
304 template<int N, typename Tuple>
308 typedef detail::_element_type<N> nth_type;
311 typedef typename nth_type::template inner<Tuple>::RET RET;
317 #if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
318 // special workaround for vc7:
321 struct reference_adder
331 struct reference_adder<true>
341 // Return a reference to the Nth type of the given Tuple
342 template<int N, typename Tuple>
346 typedef typename element<N, Tuple>::RET elt_type;
347 enum { is_ref = is_reference<elt_type>::value };
350 typedef reference_adder<is_ref>::rebind<elt_type>::type RET;
354 // Return a const reference to the Nth type of the given Tuple
355 template<int N, typename Tuple>
356 struct element_const_ref
359 typedef typename element<N, Tuple>::RET elt_type;
360 enum { is_ref = is_reference<elt_type>::value };
363 typedef reference_adder<is_ref>::rebind<const elt_type>::type RET;
369 // Return a reference to the Nth type of the given Tuple
370 template<int N, typename Tuple>
374 typedef typename element<N, Tuple>::RET elt_type;
377 typedef typename add_reference<elt_type>::type RET;
381 // Return a const reference to the Nth type of the given Tuple
382 template<int N, typename Tuple>
383 struct element_const_ref
386 typedef typename element<N, Tuple>::RET elt_type;
389 typedef typename add_reference<const elt_type>::type RET;
394 } // namespace detail
396 // Get length of this tuple
397 template<typename Tuple>
400 BOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
403 template<> struct length<tuple<> > {
404 BOOST_STATIC_CONSTANT(int, value = 0);
408 struct length<null_type>
410 BOOST_STATIC_CONSTANT(int, value = 0);
415 // Reference the Nth element in a tuple and retrieve it with "get"
419 template<typename Head, typename Tail>
421 typename detail::element_ref<N, cons<Head, Tail> >::RET
422 get(cons<Head, Tail>& t)
424 return get_class<N-1>::get(t.tail);
427 template<typename Head, typename Tail>
429 typename detail::element_const_ref<N, cons<Head, Tail> >::RET
430 get(const cons<Head, Tail>& t)
432 return get_class<N-1>::get(t.tail);
439 template<typename Head, typename Tail>
441 typename add_reference<Head>::type
442 get(cons<Head, Tail>& t)
447 template<typename Head, typename Tail>
449 typename add_reference<const Head>::type
450 get(const cons<Head, Tail>& t)
456 } // namespace detail
472 public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
475 typedef detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> mapped_tuple;
476 typedef typename mapped_tuple::cons10 cons10;
477 typedef typename mapped_tuple::cons9 cons9;
478 typedef typename mapped_tuple::cons8 cons8;
479 typedef typename mapped_tuple::cons7 cons7;
480 typedef typename mapped_tuple::cons6 cons6;
481 typedef typename mapped_tuple::cons5 cons5;
482 typedef typename mapped_tuple::cons4 cons4;
483 typedef typename mapped_tuple::cons3 cons3;
484 typedef typename mapped_tuple::cons2 cons2;
485 typedef typename mapped_tuple::cons1 cons1;
487 typedef typename detail::add_const_reference<T1>::type t1_cref;
488 typedef typename detail::add_const_reference<T2>::type t2_cref;
489 typedef typename detail::add_const_reference<T3>::type t3_cref;
490 typedef typename detail::add_const_reference<T4>::type t4_cref;
491 typedef typename detail::add_const_reference<T5>::type t5_cref;
492 typedef typename detail::add_const_reference<T6>::type t6_cref;
493 typedef typename detail::add_const_reference<T7>::type t7_cref;
494 typedef typename detail::add_const_reference<T8>::type t8_cref;
495 typedef typename detail::add_const_reference<T9>::type t9_cref;
496 typedef typename detail::add_const_reference<T10>::type t10_cref;
498 typedef cons1 inherited;
499 typedef tuple self_type;
501 tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
516 cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
520 explicit tuple(t1_cref t1)
521 : cons1(t1, cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
524 template<typename Head, typename Tail>
525 tuple(const cons<Head, Tail>& other) :
526 cons1(other.head, other.tail)
530 template<typename First, typename Second>
531 self_type& operator=(const std::pair<First, Second>& other)
533 this->head = other.first;
534 this->tail.head = other.second;
538 template<typename Head, typename Tail>
539 self_type& operator=(const cons<Head, Tail>& other)
541 this->head = other.head;
542 this->tail = other.tail;
550 template<int N> struct workaround_holder {};
552 } // namespace detail
554 template<int N, typename Head, typename Tail>
555 typename detail::element_ref<N, cons<Head, Tail> >::RET
556 get(cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
558 return detail::get_class<N>::get(t);
561 template<int N, typename Head, typename Tail>
562 typename detail::element_const_ref<N, cons<Head, Tail> >::RET
563 get(const cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
565 return detail::get_class<N>::get(t);
569 template<typename T1>
572 make_tuple(const T1& t1)
574 return tuple<T1>(t1);
578 template<typename T1, typename T2>
581 make_tuple(const T1& t1, const T2& t2)
583 return tuple<T1, T2>(t1, t2);
587 template<typename T1, typename T2, typename T3>
590 make_tuple(const T1& t1, const T2& t2, const T3& t3)
592 return tuple<T1, T2, T3>(t1, t2, t3);
596 template<typename T1, typename T2, typename T3, typename T4>
598 tuple<T1, T2, T3, T4>
599 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4)
601 return tuple<T1, T2, T3, T4>(t1, t2, t3, t4);
605 template<typename T1, typename T2, typename T3, typename T4, typename T5>
607 tuple<T1, T2, T3, T4, T5>
608 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5)
610 return tuple<T1, T2, T3, T4, T5>(t1, t2, t3, t4, t5);
614 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
616 tuple<T1, T2, T3, T4, T5, T6>
617 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6)
619 return tuple<T1, T2, T3, T4, T5, T6>(t1, t2, t3, t4, t5, t6);
623 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
625 tuple<T1, T2, T3, T4, T5, T6, T7>
626 make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7)
628 return tuple<T1, T2, T3, T4, T5, T6, T7>(t1, t2, t3, t4, t5, t6, t7);
632 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
634 tuple<T1, T2, T3, T4, T5, T6, T7, T8>
635 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)
637 return tuple<T1, T2, T3, T4, T5, T6, T7, T8>(t1, t2, t3, t4, t5, t6, t7, t8);
641 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
643 tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
644 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)
646 return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>(t1, t2, t3, t4, t5, t6, t7, t8, t9);
650 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
652 tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
653 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)
655 return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
658 // Tie variables into a tuple
659 template<typename T1>
661 tuple<detail::assign_to_pointee<T1> >
664 return make_tuple(detail::assign_to_pointee<T1>(&t1));
667 // Tie variables into a tuple
668 template<typename T1, typename T2>
670 tuple<detail::assign_to_pointee<T1>,
671 detail::assign_to_pointee<T2> >
674 return make_tuple(detail::assign_to_pointee<T1>(&t1),
675 detail::assign_to_pointee<T2>(&t2));
678 // Tie variables into a tuple
679 template<typename T1, typename T2, typename T3>
681 tuple<detail::assign_to_pointee<T1>,
682 detail::assign_to_pointee<T2>,
683 detail::assign_to_pointee<T3> >
684 tie(T1& t1, T2& t2, T3& t3)
686 return make_tuple(detail::assign_to_pointee<T1>(&t1),
687 detail::assign_to_pointee<T2>(&t2),
688 detail::assign_to_pointee<T3>(&t3));
691 // Tie variables into a tuple
692 template<typename T1, typename T2, typename T3, typename T4>
694 tuple<detail::assign_to_pointee<T1>,
695 detail::assign_to_pointee<T2>,
696 detail::assign_to_pointee<T3>,
697 detail::assign_to_pointee<T4> >
698 tie(T1& t1, T2& t2, T3& t3, T4& t4)
700 return make_tuple(detail::assign_to_pointee<T1>(&t1),
701 detail::assign_to_pointee<T2>(&t2),
702 detail::assign_to_pointee<T3>(&t3),
703 detail::assign_to_pointee<T4>(&t4));
706 // Tie variables into a tuple
707 template<typename T1, typename T2, typename T3, typename T4, typename T5>
709 tuple<detail::assign_to_pointee<T1>,
710 detail::assign_to_pointee<T2>,
711 detail::assign_to_pointee<T3>,
712 detail::assign_to_pointee<T4>,
713 detail::assign_to_pointee<T5> >
714 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5)
716 return make_tuple(detail::assign_to_pointee<T1>(&t1),
717 detail::assign_to_pointee<T2>(&t2),
718 detail::assign_to_pointee<T3>(&t3),
719 detail::assign_to_pointee<T4>(&t4),
720 detail::assign_to_pointee<T5>(&t5));
723 // Tie variables into a tuple
724 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
726 tuple<detail::assign_to_pointee<T1>,
727 detail::assign_to_pointee<T2>,
728 detail::assign_to_pointee<T3>,
729 detail::assign_to_pointee<T4>,
730 detail::assign_to_pointee<T5>,
731 detail::assign_to_pointee<T6> >
732 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6)
734 return make_tuple(detail::assign_to_pointee<T1>(&t1),
735 detail::assign_to_pointee<T2>(&t2),
736 detail::assign_to_pointee<T3>(&t3),
737 detail::assign_to_pointee<T4>(&t4),
738 detail::assign_to_pointee<T5>(&t5),
739 detail::assign_to_pointee<T6>(&t6));
742 // Tie variables into a tuple
743 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
745 tuple<detail::assign_to_pointee<T1>,
746 detail::assign_to_pointee<T2>,
747 detail::assign_to_pointee<T3>,
748 detail::assign_to_pointee<T4>,
749 detail::assign_to_pointee<T5>,
750 detail::assign_to_pointee<T6>,
751 detail::assign_to_pointee<T7> >
752 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7)
754 return make_tuple(detail::assign_to_pointee<T1>(&t1),
755 detail::assign_to_pointee<T2>(&t2),
756 detail::assign_to_pointee<T3>(&t3),
757 detail::assign_to_pointee<T4>(&t4),
758 detail::assign_to_pointee<T5>(&t5),
759 detail::assign_to_pointee<T6>(&t6),
760 detail::assign_to_pointee<T7>(&t7));
763 // Tie variables into a tuple
764 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
766 tuple<detail::assign_to_pointee<T1>,
767 detail::assign_to_pointee<T2>,
768 detail::assign_to_pointee<T3>,
769 detail::assign_to_pointee<T4>,
770 detail::assign_to_pointee<T5>,
771 detail::assign_to_pointee<T6>,
772 detail::assign_to_pointee<T7>,
773 detail::assign_to_pointee<T8> >
774 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8)
776 return make_tuple(detail::assign_to_pointee<T1>(&t1),
777 detail::assign_to_pointee<T2>(&t2),
778 detail::assign_to_pointee<T3>(&t3),
779 detail::assign_to_pointee<T4>(&t4),
780 detail::assign_to_pointee<T5>(&t5),
781 detail::assign_to_pointee<T6>(&t6),
782 detail::assign_to_pointee<T7>(&t7),
783 detail::assign_to_pointee<T8>(&t8));
786 // Tie variables into a tuple
787 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
789 tuple<detail::assign_to_pointee<T1>,
790 detail::assign_to_pointee<T2>,
791 detail::assign_to_pointee<T3>,
792 detail::assign_to_pointee<T4>,
793 detail::assign_to_pointee<T5>,
794 detail::assign_to_pointee<T6>,
795 detail::assign_to_pointee<T7>,
796 detail::assign_to_pointee<T8>,
797 detail::assign_to_pointee<T9> >
798 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9)
800 return make_tuple(detail::assign_to_pointee<T1>(&t1),
801 detail::assign_to_pointee<T2>(&t2),
802 detail::assign_to_pointee<T3>(&t3),
803 detail::assign_to_pointee<T4>(&t4),
804 detail::assign_to_pointee<T5>(&t5),
805 detail::assign_to_pointee<T6>(&t6),
806 detail::assign_to_pointee<T7>(&t7),
807 detail::assign_to_pointee<T8>(&t8),
808 detail::assign_to_pointee<T9>(&t9));
810 // Tie variables into a tuple
811 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
813 tuple<detail::assign_to_pointee<T1>,
814 detail::assign_to_pointee<T2>,
815 detail::assign_to_pointee<T3>,
816 detail::assign_to_pointee<T4>,
817 detail::assign_to_pointee<T5>,
818 detail::assign_to_pointee<T6>,
819 detail::assign_to_pointee<T7>,
820 detail::assign_to_pointee<T8>,
821 detail::assign_to_pointee<T9>,
822 detail::assign_to_pointee<T10> >
823 tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10)
825 return make_tuple(detail::assign_to_pointee<T1>(&t1),
826 detail::assign_to_pointee<T2>(&t2),
827 detail::assign_to_pointee<T3>(&t3),
828 detail::assign_to_pointee<T4>(&t4),
829 detail::assign_to_pointee<T5>(&t5),
830 detail::assign_to_pointee<T6>(&t6),
831 detail::assign_to_pointee<T7>(&t7),
832 detail::assign_to_pointee<T8>(&t8),
833 detail::assign_to_pointee<T9>(&t9),
834 detail::assign_to_pointee<T10>(&t10));
836 // "ignore" allows tuple positions to be ignored when using "tie".
838 detail::swallow_assign const ignore = detail::swallow_assign();
840 template <class T0, class T1, class T2, class T3, class T4,
841 class T5, class T6, class T7, class T8, class T9>
842 void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
843 tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs);
844 inline void swap(null_type&, null_type&) {}
846 inline void swap(cons<HH, null_type>& lhs, cons<HH, null_type>& rhs) {
847 ::boost::swap(lhs.head, rhs.head);
849 template<class HH, class TT>
850 inline void swap(cons<HH, TT>& lhs, cons<HH, TT>& rhs) {
851 ::boost::swap(lhs.head, rhs.head);
852 ::boost::tuples::swap(lhs.tail, rhs.tail);
854 template <class T0, class T1, class T2, class T3, class T4,
855 class T5, class T6, class T7, class T8, class T9>
856 inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
857 tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs) {
858 typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tuple_type;
859 typedef typename tuple_type::inherited base;
860 ::boost::tuples::swap(static_cast<base&>(lhs), static_cast<base&>(rhs));
863 } // namespace tuples
865 #endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP