source: NonGTP/Boost/boost/tuple/detail/tuple_basic_no_partial_spec.hpp @ 857

Revision 857, 26.9 KB checked in by igarcia, 18 years ago (diff)
Line 
1// - tuple_basic_no_partial_spec.hpp -----------------------------------------
2
3// Copyright (C) 1999, 2000 Jaakko Järvi (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
38namespace boost {
39namespace 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, == 1200)
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
837detail::swallow_assign const ignore = detail::swallow_assign();
838
839} // namespace tuples
840} // namespace boost
841#endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
Note: See TracBrowser for help on using the repository browser.