1 // tuple_basic.hpp -----------------------------------------------------
3 // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
5 // Distributed under the Boost Software License, Version 1.0. (See
6 // accompanying file LICENSE_1_0.txt or copy at
7 // http://www.boost.org/LICENSE_1_0.txt)
9 // For more information, see http://www.boost.org
12 // This and that, Gary Powell.
13 // Fixed return types for get_head/get_tail
14 // ( and other bugs ) per suggestion of Jens Maurer
15 // simplified element type accessors + bug fix (Jeremy Siek)
16 // Several changes/additions according to suggestions by Douglas Gregor,
17 // William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes,
21 // 2002 05 01 Hugo Duncan: Fix for Borland after Jaakko's previous changes
22 // 2002 04 18 Jaakko: tuple element types can be void or plain function
23 // types, as long as no object is created.
24 // Tuple objects can no hold even noncopyable types
26 // 2001 10 22 John Maddock
27 // Fixes for Borland C++
28 // 2001 08 30 David Abrahams
29 // Added default constructor for cons<>.
30 // -----------------------------------------------------------------
32 #ifndef BOOST_TUPLE_BASIC_HPP
33 #define BOOST_TUPLE_BASIC_HPP
36 #include <utility> // needed for the assignment from pair to tuple
38 #include <boost/type_traits/cv_traits.hpp>
39 #include <boost/type_traits/function_traits.hpp>
40 #include <boost/utility/swap.hpp>
42 #include <boost/detail/workaround.hpp> // needed for BOOST_WORKAROUND
44 #if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
45 #pragma GCC diagnostic push
46 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
52 // -- null_type --------------------------------------------------------
55 // a helper function to provide a const null_type type temporary
57 inline const null_type cnull() { return null_type(); }
60 // -- if construct ------------------------------------------------
61 // Proposed by Krzysztof Czarnecki and Ulrich Eisenecker
63 template <bool If, class Then, class Else> struct IF { typedef Then RET; };
65 template <class Then, class Else> struct IF<false, Then, Else> {
71 // - cons forward declaration -----------------------------------------------
72 template <class HT, class TT> struct cons;
75 // - tuple forward declaration -----------------------------------------------
77 class T0 = null_type, class T1 = null_type, class T2 = null_type,
78 class T3 = null_type, class T4 = null_type, class T5 = null_type,
79 class T6 = null_type, class T7 = null_type, class T8 = null_type,
83 // tuple_length forward declaration
84 template<class T> struct length;
90 // -- generate error template, referencing to non-existing members of this
91 // template is used to produce compilation errors intentionally
99 typedef BOOST_DEDUCED_TYPENAME drop_front<N-1>::BOOST_NESTED_TEMPLATE
101 typedef BOOST_DEDUCED_TYPENAME next::type::tail_type type;
102 static const type& call(const Tuple& tup) {
103 return next::call(tup).tail;
109 struct drop_front<0> {
110 template<class Tuple>
113 static const type& call(const Tuple& tup) {
119 } // end of namespace detail
122 // -cons type accessors ----------------------------------------
123 // typename tuples::element<N,T>::type gets the type of the
124 // Nth element ot T, first element is at index 0
125 // -------------------------------------------------------
127 #ifndef BOOST_NO_CV_SPECIALIZATIONS
129 template<int N, class T>
132 typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
133 apply<T>::type::head_type type;
136 template<int N, class T>
137 struct element<N, const T>
140 typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
141 apply<T>::type::head_type unqualified_type;
143 #if BOOST_WORKAROUND(__BORLANDC__,<0x600)
144 typedef const unqualified_type type;
146 typedef BOOST_DEDUCED_TYPENAME boost::add_const<unqualified_type>::type type;
149 #else // def BOOST_NO_CV_SPECIALIZATIONS
153 template<int N, class T, bool IsConst>
156 typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
157 apply<T>::type::head_type type;
160 template<int N, class T>
161 struct element_impl<N, T, true /* IsConst */>
163 typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
164 apply<T>::type::head_type unqualified_type;
165 typedef const unqualified_type type;
168 } // end of namespace detail
171 template<int N, class T>
173 public detail::element_impl<N, T, ::boost::is_const<T>::value>
180 // -get function templates -----------------------------------------------
181 // Usage: get<N>(aTuple)
183 // -- some traits classes for get functions
185 // access traits lifted from detail namespace to be part of the interface,
186 // (Joel de Guzman's suggestion). Rationale: get functions are part of the
187 // interface, so should the way to express their return types be.
189 template <class T> struct access_traits {
190 typedef const T& const_type;
191 typedef T& non_const_type;
193 typedef const typename boost::remove_cv<T>::type& parameter_type;
195 // used as the tuple constructors parameter types
196 // Rationale: non-reference tuple element types can be cv-qualified.
197 // It should be possible to initialize such types with temporaries,
198 // and when binding temporaries to references, the reference must
199 // be non-volatile and const. 8.5.3. (5)
202 template <class T> struct access_traits<T&> {
204 typedef T& const_type;
205 typedef T& non_const_type;
207 typedef T& parameter_type;
210 // get function for non-const cons-lists, returns a reference to the element
212 template<int N, class HT, class TT>
213 inline typename access_traits<
214 typename element<N, cons<HT, TT> >::type
216 get(cons<HT, TT>& c) {
217 typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
218 apply<cons<HT, TT> > impl;
219 typedef BOOST_DEDUCED_TYPENAME impl::type cons_element;
220 return const_cast<cons_element&>(impl::call(c)).head;
223 // get function for const cons-lists, returns a const reference to
224 // the element. If the element is a reference, returns the reference
225 // as such (that is, can return a non-const reference)
226 template<int N, class HT, class TT>
227 inline typename access_traits<
228 typename element<N, cons<HT, TT> >::type
230 get(const cons<HT, TT>& c) {
231 typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
232 apply<cons<HT, TT> > impl;
233 return impl::call(c).head;
236 // -- the cons template --------------------------------------------------
239 // These helper templates wrap void types and plain function types.
240 // The reationale is to allow one to write tuple types with those types
241 // as elements, even though it is not possible to instantiate such object.
242 // E.g: typedef tuple<void> some_type; // ok
243 // but: some_type x; // fails
245 template <class T> class non_storeable_type {
246 non_storeable_type();
249 template <class T> struct wrap_non_storeable_type {
251 ::boost::is_function<T>::value, non_storeable_type<T>, T
254 template <> struct wrap_non_storeable_type<void> {
255 typedef non_storeable_type<void> type;
260 template <class HT, class TT>
263 typedef HT head_type;
264 typedef TT tail_type;
267 detail::wrap_non_storeable_type<head_type>::type stored_head_type;
269 stored_head_type head;
272 typename access_traits<stored_head_type>::non_const_type
273 get_head() { return head; }
275 typename access_traits<tail_type>::non_const_type
276 get_tail() { return tail; }
278 typename access_traits<stored_head_type>::const_type
279 get_head() const { return head; }
281 typename access_traits<tail_type>::const_type
282 get_tail() const { return tail; }
284 cons() : head(), tail() {}
285 // cons() : head(detail::default_arg<HT>::f()), tail() {}
287 // the argument for head is not strictly needed, but it prevents
288 // array type elements. This is good, since array type elements
289 // cannot be supported properly in any case (no assignment,
290 // copy works only if the tails are exactly the same type, ...)
292 cons(typename access_traits<stored_head_type>::parameter_type h,
294 : head (h), tail(t) {}
296 template <class T1, class T2, class T3, class T4, class T5,
297 class T6, class T7, class T8, class T9, class T10>
298 cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
299 T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
301 tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
304 template <class T2, class T3, class T4, class T5,
305 class T6, class T7, class T8, class T9, class T10>
306 cons( const null_type& /*t1*/, T2& t2, T3& t3, T4& t4, T5& t5,
307 T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
309 tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
313 template <class HT2, class TT2>
314 cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}
316 template <class HT2, class TT2>
317 cons& operator=( const cons<HT2, TT2>& u ) {
318 head=u.head; tail=u.tail; return *this;
321 // must define assignment operator explicitly, implicit version is
322 // illformed if HT is a reference (12.8. (12))
323 cons& operator=(const cons& u) {
324 head = u.head; tail = u.tail; return *this;
327 template <class T1, class T2>
328 cons& operator=( const std::pair<T1, T2>& u ) {
329 BOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2
330 head = u.first; tail.head = u.second; return *this;
333 // get member functions (non-const and const)
335 typename access_traits<
336 typename element<N, cons<HT, TT> >::type
339 return boost::tuples::get<N>(*this); // delegate to non-member get
343 typename access_traits<
344 typename element<N, cons<HT, TT> >::type
347 return boost::tuples::get<N>(*this); // delegate to non-member get
352 struct cons<HT, null_type> {
354 typedef HT head_type;
355 typedef null_type tail_type;
356 typedef cons<HT, null_type> self_type;
359 detail::wrap_non_storeable_type<head_type>::type stored_head_type;
360 stored_head_type head;
362 typename access_traits<stored_head_type>::non_const_type
363 get_head() { return head; }
365 null_type get_tail() { return null_type(); }
367 typename access_traits<stored_head_type>::const_type
368 get_head() const { return head; }
370 const null_type get_tail() const { return null_type(); }
372 // cons() : head(detail::default_arg<HT>::f()) {}
375 cons(typename access_traits<stored_head_type>::parameter_type h,
376 const null_type& = null_type())
380 cons(T1& t1, const null_type&, const null_type&, const null_type&,
381 const null_type&, const null_type&, const null_type&,
382 const null_type&, const null_type&, const null_type&)
385 cons(const null_type&,
386 const null_type&, const null_type&, const null_type&,
387 const null_type&, const null_type&, const null_type&,
388 const null_type&, const null_type&, const null_type&)
392 cons( const cons<HT2, null_type>& u ) : head(u.head) {}
395 cons& operator=(const cons<HT2, null_type>& u )
396 { head = u.head; return *this; }
398 // must define assignment operator explicitely, implicit version
399 // is illformed if HT is a reference
400 cons& operator=(const cons& u) { head = u.head; return *this; }
403 typename access_traits<
404 typename element<N, self_type>::type
407 return boost::tuples::get<N>(*this);
411 typename access_traits<
412 typename element<N, self_type>::type
415 return boost::tuples::get<N>(*this);
420 // templates for finding out the length of the tuple -------------------
424 BOOST_STATIC_CONSTANT(int, value = 1 + length<typename T::tail_type>::value);
428 struct length<tuple<> > {
429 BOOST_STATIC_CONSTANT(int, value = 0);
433 struct length<tuple<> const> {
434 BOOST_STATIC_CONSTANT(int, value = 0);
438 struct length<null_type> {
439 BOOST_STATIC_CONSTANT(int, value = 0);
443 struct length<null_type const> {
444 BOOST_STATIC_CONSTANT(int, value = 0);
449 // Tuple to cons mapper --------------------------------------------------
450 template <class T0, class T1, class T2, class T3, class T4,
451 class T5, class T6, class T7, class T8, class T9>
452 struct map_tuple_to_cons
455 typename map_tuple_to_cons<T1, T2, T3, T4, T5,
456 T6, T7, T8, T9, null_type>::type
460 // The empty tuple is a null_type
462 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>
464 typedef null_type type;
469 // -------------------------------------------------------------------
470 // -- tuple ------------------------------------------------------
471 template <class T0, class T1, class T2, class T3, class T4,
472 class T5, class T6, class T7, class T8, class T9>
475 public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
479 detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
480 typedef typename inherited::head_type head_type;
481 typedef typename inherited::tail_type tail_type;
484 // access_traits<T>::parameter_type takes non-reference types as const T&
487 explicit tuple(typename access_traits<T0>::parameter_type t0)
488 : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
489 detail::cnull(), detail::cnull(), detail::cnull(),
490 detail::cnull(), detail::cnull(), detail::cnull()) {}
492 tuple(typename access_traits<T0>::parameter_type t0,
493 typename access_traits<T1>::parameter_type t1)
494 : inherited(t0, t1, detail::cnull(), detail::cnull(),
495 detail::cnull(), detail::cnull(), detail::cnull(),
496 detail::cnull(), detail::cnull(), detail::cnull()) {}
498 tuple(typename access_traits<T0>::parameter_type t0,
499 typename access_traits<T1>::parameter_type t1,
500 typename access_traits<T2>::parameter_type t2)
501 : inherited(t0, t1, t2, detail::cnull(), detail::cnull(),
502 detail::cnull(), detail::cnull(), detail::cnull(),
503 detail::cnull(), detail::cnull()) {}
505 tuple(typename access_traits<T0>::parameter_type t0,
506 typename access_traits<T1>::parameter_type t1,
507 typename access_traits<T2>::parameter_type t2,
508 typename access_traits<T3>::parameter_type t3)
509 : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),
510 detail::cnull(), detail::cnull(), detail::cnull(),
513 tuple(typename access_traits<T0>::parameter_type t0,
514 typename access_traits<T1>::parameter_type t1,
515 typename access_traits<T2>::parameter_type t2,
516 typename access_traits<T3>::parameter_type t3,
517 typename access_traits<T4>::parameter_type t4)
518 : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),
519 detail::cnull(), detail::cnull(), detail::cnull()) {}
521 tuple(typename access_traits<T0>::parameter_type t0,
522 typename access_traits<T1>::parameter_type t1,
523 typename access_traits<T2>::parameter_type t2,
524 typename access_traits<T3>::parameter_type t3,
525 typename access_traits<T4>::parameter_type t4,
526 typename access_traits<T5>::parameter_type t5)
527 : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),
528 detail::cnull(), detail::cnull()) {}
530 tuple(typename access_traits<T0>::parameter_type t0,
531 typename access_traits<T1>::parameter_type t1,
532 typename access_traits<T2>::parameter_type t2,
533 typename access_traits<T3>::parameter_type t3,
534 typename access_traits<T4>::parameter_type t4,
535 typename access_traits<T5>::parameter_type t5,
536 typename access_traits<T6>::parameter_type t6)
537 : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),
538 detail::cnull(), detail::cnull()) {}
540 tuple(typename access_traits<T0>::parameter_type t0,
541 typename access_traits<T1>::parameter_type t1,
542 typename access_traits<T2>::parameter_type t2,
543 typename access_traits<T3>::parameter_type t3,
544 typename access_traits<T4>::parameter_type t4,
545 typename access_traits<T5>::parameter_type t5,
546 typename access_traits<T6>::parameter_type t6,
547 typename access_traits<T7>::parameter_type t7)
548 : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),
551 tuple(typename access_traits<T0>::parameter_type t0,
552 typename access_traits<T1>::parameter_type t1,
553 typename access_traits<T2>::parameter_type t2,
554 typename access_traits<T3>::parameter_type t3,
555 typename access_traits<T4>::parameter_type t4,
556 typename access_traits<T5>::parameter_type t5,
557 typename access_traits<T6>::parameter_type t6,
558 typename access_traits<T7>::parameter_type t7,
559 typename access_traits<T8>::parameter_type t8)
560 : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {}
562 tuple(typename access_traits<T0>::parameter_type t0,
563 typename access_traits<T1>::parameter_type t1,
564 typename access_traits<T2>::parameter_type t2,
565 typename access_traits<T3>::parameter_type t3,
566 typename access_traits<T4>::parameter_type t4,
567 typename access_traits<T5>::parameter_type t5,
568 typename access_traits<T6>::parameter_type t6,
569 typename access_traits<T7>::parameter_type t7,
570 typename access_traits<T8>::parameter_type t8,
571 typename access_traits<T9>::parameter_type t9)
572 : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
575 template<class U1, class U2>
576 tuple(const cons<U1, U2>& p) : inherited(p) {}
578 template <class U1, class U2>
579 tuple& operator=(const cons<U1, U2>& k) {
580 inherited::operator=(k);
584 template <class U1, class U2>
585 tuple& operator=(const std::pair<U1, U2>& k) {
586 BOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2
587 this->head = k.first;
588 this->tail.head = k.second;
596 class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type> :
600 typedef null_type inherited;
604 // Swallows any assignment (by Doug Gregor)
607 struct swallow_assign;
608 typedef void (detail::swallow_assign::*ignore_t)();
609 struct swallow_assign {
610 swallow_assign(ignore_t(*)(ignore_t)) {}
612 swallow_assign const& operator=(const T&) const {
618 } // namespace detail
620 // "ignore" allows tuple positions to be ignored when using "tie".
621 inline detail::ignore_t ignore(detail::ignore_t) { return 0; }
623 // ---------------------------------------------------------------------------
624 // The call_traits for make_tuple
625 // Honours the reference_wrapper class.
627 // Must be instantiated with plain or const plain types (not with references)
629 // from template<class T> foo(const T& t) : make_tuple_traits<const T>::type
630 // from template<class T> foo(T& t) : make_tuple_traits<T>::type
634 // references -> compile_time_error
635 // reference_wrapper<T> -> T&
636 // const reference_wrapper<T> -> T&
637 // array -> const ref array
641 struct make_tuple_traits {
644 // commented away, see below (JJ)
645 // typedef typename IF<
646 // boost::is_function<T>::value,
652 // The is_function test was there originally for plain function types,
653 // which can't be stored as such (we must either store them as references or
654 // pointers). Such a type could be formed if make_tuple was called with a
655 // reference to a function.
656 // But this would mean that a const qualified function type was formed in
657 // the make_tuple function and hence make_tuple can't take a function
658 // reference as a parameter, and thus T can't be a function type.
659 // So is_function test was removed.
660 // (14.8.3. says that type deduction fails if a cv-qualified function type
661 // is created. (It only applies for the case of explicitly specifying template
662 // args, though?)) (JJ)
665 struct make_tuple_traits<T&> {
667 detail::generate_error<T&>::
668 do_not_use_with_reference_type error;
671 // Arrays can't be stored as plain types; convert them to references.
672 // All arrays are converted to const. This is because make_tuple takes its
673 // parameters as const T& and thus the knowledge of the potential
674 // non-constness of actual argument is lost.
675 template<class T, int n> struct make_tuple_traits <T[n]> {
676 typedef const T (&type)[n];
679 template<class T, int n>
680 struct make_tuple_traits<const T[n]> {
681 typedef const T (&type)[n];
684 template<class T, int n> struct make_tuple_traits<volatile T[n]> {
685 typedef const volatile T (&type)[n];
688 template<class T, int n>
689 struct make_tuple_traits<const volatile T[n]> {
690 typedef const volatile T (&type)[n];
694 struct make_tuple_traits<reference_wrapper<T> >{
699 struct make_tuple_traits<const reference_wrapper<T> >{
704 struct make_tuple_traits<detail::ignore_t(detail::ignore_t)> {
705 typedef detail::swallow_assign type;
712 // a helper traits to make the make_tuple functions shorter (Vesa Karvonen's
715 class T0 = null_type, class T1 = null_type, class T2 = null_type,
716 class T3 = null_type, class T4 = null_type, class T5 = null_type,
717 class T6 = null_type, class T7 = null_type, class T8 = null_type,
720 struct make_tuple_mapper {
722 tuple<typename make_tuple_traits<T0>::type,
723 typename make_tuple_traits<T1>::type,
724 typename make_tuple_traits<T2>::type,
725 typename make_tuple_traits<T3>::type,
726 typename make_tuple_traits<T4>::type,
727 typename make_tuple_traits<T5>::type,
728 typename make_tuple_traits<T6>::type,
729 typename make_tuple_traits<T7>::type,
730 typename make_tuple_traits<T8>::type,
731 typename make_tuple_traits<T9>::type> type;
736 // -make_tuple function templates -----------------------------------
737 inline tuple<> make_tuple() {
742 inline typename detail::make_tuple_mapper<T0>::type
743 make_tuple(const T0& t0) {
744 typedef typename detail::make_tuple_mapper<T0>::type t;
748 template<class T0, class T1>
749 inline typename detail::make_tuple_mapper<T0, T1>::type
750 make_tuple(const T0& t0, const T1& t1) {
751 typedef typename detail::make_tuple_mapper<T0, T1>::type t;
755 template<class T0, class T1, class T2>
756 inline typename detail::make_tuple_mapper<T0, T1, T2>::type
757 make_tuple(const T0& t0, const T1& t1, const T2& t2) {
758 typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t;
759 return t(t0, t1, t2);
762 template<class T0, class T1, class T2, class T3>
763 inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
764 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
765 typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t;
766 return t(t0, t1, t2, t3);
769 template<class T0, class T1, class T2, class T3, class T4>
770 inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
771 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
773 typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
774 return t(t0, t1, t2, t3, t4);
777 template<class T0, class T1, class T2, class T3, class T4, class T5>
778 inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
779 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
780 const T4& t4, const T5& t5) {
781 typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
782 return t(t0, t1, t2, t3, t4, t5);
785 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
786 inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::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) {
789 typedef typename detail::make_tuple_mapper
790 <T0, T1, T2, T3, T4, T5, T6>::type t;
791 return t(t0, t1, t2, t3, t4, t5, t6);
794 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
796 inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
797 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
798 const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
799 typedef typename detail::make_tuple_mapper
800 <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
801 return t(t0, t1, t2, t3, t4, t5, t6, t7);
804 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
806 inline typename detail::make_tuple_mapper
807 <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
808 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
809 const T4& t4, const T5& t5, const T6& t6, const T7& t7,
811 typedef typename detail::make_tuple_mapper
812 <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
813 return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
816 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
817 class T7, class T8, class T9>
818 inline typename detail::make_tuple_mapper
819 <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
820 make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
821 const T4& t4, const T5& t5, const T6& t6, const T7& t7,
822 const T8& t8, const T9& t9) {
823 typedef typename detail::make_tuple_mapper
824 <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
825 return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
836 struct tie_traits<ignore_t(ignore_t)> {
837 typedef swallow_assign type;
841 struct tie_traits<void> {
842 typedef null_type type;
846 class T0 = void, class T1 = void, class T2 = void,
847 class T3 = void, class T4 = void, class T5 = void,
848 class T6 = void, class T7 = void, class T8 = void,
853 tuple<typename tie_traits<T0>::type,
854 typename tie_traits<T1>::type,
855 typename tie_traits<T2>::type,
856 typename tie_traits<T3>::type,
857 typename tie_traits<T4>::type,
858 typename tie_traits<T5>::type,
859 typename tie_traits<T6>::type,
860 typename tie_traits<T7>::type,
861 typename tie_traits<T8>::type,
862 typename tie_traits<T9>::type> type;
867 // Tie function templates -------------------------------------------------
869 inline typename detail::tie_mapper<T0>::type
871 typedef typename detail::tie_mapper<T0>::type t;
875 template<class T0, class T1>
876 inline typename detail::tie_mapper<T0, T1>::type
877 tie(T0& t0, T1& t1) {
878 typedef typename detail::tie_mapper<T0, T1>::type t;
882 template<class T0, class T1, class T2>
883 inline typename detail::tie_mapper<T0, T1, T2>::type
884 tie(T0& t0, T1& t1, T2& t2) {
885 typedef typename detail::tie_mapper<T0, T1, T2>::type t;
886 return t(t0, t1, t2);
889 template<class T0, class T1, class T2, class T3>
890 inline typename detail::tie_mapper<T0, T1, T2, T3>::type
891 tie(T0& t0, T1& t1, T2& t2, T3& t3) {
892 typedef typename detail::tie_mapper<T0, T1, T2, T3>::type t;
893 return t(t0, t1, t2, t3);
896 template<class T0, class T1, class T2, class T3, class T4>
897 inline typename detail::tie_mapper<T0, T1, T2, T3, T4>::type
898 tie(T0& t0, T1& t1, T2& t2, T3& t3,
900 typedef typename detail::tie_mapper<T0, T1, T2, T3, T4>::type t;
901 return t(t0, t1, t2, t3, t4);
904 template<class T0, class T1, class T2, class T3, class T4, class T5>
905 inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5>::type
906 tie(T0& t0, T1& t1, T2& t2, T3& t3,
908 typedef typename detail::tie_mapper<T0, T1, T2, T3, T4, T5>::type t;
909 return t(t0, t1, t2, t3, t4, t5);
912 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
913 inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6>::type
914 tie(T0& t0, T1& t1, T2& t2, T3& t3,
915 T4& t4, T5& t5, T6& t6) {
916 typedef typename detail::tie_mapper
917 <T0, T1, T2, T3, T4, T5, T6>::type t;
918 return t(t0, t1, t2, t3, t4, t5, t6);
921 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
923 inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
924 tie(T0& t0, T1& t1, T2& t2, T3& t3,
925 T4& t4, T5& t5, T6& t6, T7& t7) {
926 typedef typename detail::tie_mapper
927 <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
928 return t(t0, t1, t2, t3, t4, t5, t6, t7);
931 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
933 inline typename detail::tie_mapper
934 <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
935 tie(T0& t0, T1& t1, T2& t2, T3& t3,
936 T4& t4, T5& t5, T6& t6, T7& t7,
938 typedef typename detail::tie_mapper
939 <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
940 return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
943 template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
944 class T7, class T8, class T9>
945 inline typename detail::tie_mapper
946 <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
947 tie(T0& t0, T1& t1, T2& t2, T3& t3,
948 T4& t4, T5& t5, T6& t6, T7& t7,
950 typedef typename detail::tie_mapper
951 <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
952 return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
955 template <class T0, class T1, class T2, class T3, class T4,
956 class T5, class T6, class T7, class T8, class T9>
957 void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
958 tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs);
959 inline void swap(null_type&, null_type&) {}
961 inline void swap(cons<HH, null_type>& lhs, cons<HH, null_type>& rhs) {
962 ::boost::swap(lhs.head, rhs.head);
964 template<class HH, class TT>
965 inline void swap(cons<HH, TT>& lhs, cons<HH, TT>& rhs) {
966 ::boost::swap(lhs.head, rhs.head);
967 ::boost::tuples::swap(lhs.tail, rhs.tail);
969 template <class T0, class T1, class T2, class T3, class T4,
970 class T5, class T6, class T7, class T8, class T9>
971 inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
972 tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs) {
973 typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tuple_type;
974 typedef typename tuple_type::inherited base;
975 ::boost::tuples::swap(static_cast<base&>(lhs), static_cast<base&>(rhs));
978 } // end of namespace tuples
979 } // end of namespace boost
982 #if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
983 #pragma GCC diagnostic pop
987 #endif // BOOST_TUPLE_BASIC_HPP