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 |
|
---|
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, == 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 |
|
---|
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
|
---|