?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
remove \r
[extl.git] / extl / container / detail / tuple_impl.h
blob06b923d48c9404ef1ba31ef19344470fbeb29c0d
1 /* ///////////////////////////////////////////////////////////////////////
2 * File: tuple_impl.h
3 *
4 * Created: 08.07.21
5 * Updated: 08.07.24
6 *
7 * Brief: tuple class
8 *
9 * [<Home>]
10 * Copyright (c) 2008-2020, Waruqi All rights reserved.
11 * //////////////////////////////////////////////////////////////////// */
12
13 #ifndef EXTL_CONTAINER_DETAIL_TUPLE_IMPL_H
14 #define EXTL_CONTAINER_DETAIL_TUPLE_IMPL_H
15
16 #ifndef __cplusplus
17 # error tuple_impl.h need be supported by c++.
18 #endif
19
20 /* ///////////////////////////////////////////////////////////////////////
21 * Includes
22 */
23 #include "tuple2.h"
24
25 #ifdef EXTL_MPL_IF_SUPPORT
26 # include "../../mpl/if_.h"
27 #endif
28
29 #ifdef EXTL_TYPE_TRAITS_ADD_CONST_SUPPORT
30 # include "../../type/traits/add_const.h"
31 #endif
32
33 #ifdef EXTL_TYPE_TRAITS_IS_CONST_SUPPORT
34 # include "../../type/traits/is_const.h"
35 #endif
36 /* ///////////////////////////////////////////////////////////////////////
37 * ::extl namespace
38 */
39 EXTL_BEGIN_NAMESPACE
40
41 /* ///////////////////////////////////////////////////////////////////////
42 * Forward declaration
43 */
44 template< typename_param_k T0 = e_null_t
45 , typename_param_k T1 = e_null_t
46 , typename_param_k T2 = e_null_t
47 , typename_param_k T3 = e_null_t
48 , typename_param_k T4 = e_null_t
49 , typename_param_k T5 = e_null_t
50 , typename_param_k T6 = e_null_t
51 , typename_param_k T7 = e_null_t
52 , typename_param_k T8 = e_null_t
53 , typename_param_k T9 = e_null_t
54 >
55 class tuple;
56
57 template<typename_param_k T>
58 struct tuple_elements_size;
59
60 template< e_size_t N
61 , typename_param_k T
62 >
63 struct tuple_element_traits;
64
65 /* ///////////////////////////////////////////////////////////////////////
66 * ::extl::detail namespace
67 */
68 EXTL_DETAIL_BEGIN_NAMESPACE
69
70 // tuple_element_traits implemention
71 #if defined(EXTL_TEMPLATE_PARTIAL_SPEC_SUPPORT) && \
72 !EXTL_WORKAROUND_BORLAND(==, 0x551)
73
74 template< e_size_t N
75 , typename_param_k T
76 >
77 struct tuple_element_traits_impl
78 {
79 private:
80 typedef typename_type_k T::tail_type next_type;
81 public:
82 typedef typename_type_k tuple_element_traits_impl<N - 1, next_type>::type type;
83 };
84
85 template<typename_param_k T>
86 struct tuple_element_traits_impl<0, T>
87 {
88 typedef typename_type_k T::head_type type;
89 };
90 #else
91 template<e_size_t N>
92 struct tuple_element_traits_impl_helper
93 {
94 template<typename_param_k T>
95 struct result
96 {
97 private:
98 typedef typename_type_k T::tail_type next_type;
99 public:
100 typedef typename_type_k tuple_element_traits_impl_helper<N - 1>::template_qual_k result<next_type>::type type;
101 };
102 };
103 EXTL_TEMPLATE_SPECIALISATION
104 struct tuple_element_traits_impl_helper<0>
105 {
106 template<typename_param_k T>
107 struct result
108 {
109 typedef typename_type_k T::head_type type;
110 };
111 };
112 template< e_size_t N
113 , typename_param_k T
114 >
115 struct tuple_element_traits_impl
116 : tuple_element_traits_impl_helper<N>::template_qual_k result<T>
117 {
118
119 };
120 #endif
121 /* ///////////////////////////////////////////////////////////////////////
122 * ::extl::detail namespace
123 */
124 EXTL_DETAIL_END_NAMESPACE
125
126 /*!\brief tuple_element_traits class
127 *
128 * \param N The sequence number of elements
129 * \param T The tuple<>/EXTL_NS_DETAIL(tuple2)<> type
130 *
131 * \ingroup extl_group_container
132 */
133 template< e_size_t N
134 , typename_param_k T
135 >
136 struct tuple_element_traits
137 {
138 private:
139 typedef typename_type_k EXTL_NS_DETAIL(tuple_element_traits_impl)<N, T>::type old_type_;
140
141 /// \name Types
142 /// @{
143 public:
144 // The element type will be added const-qualified if tuple<> is const-qualified
145 #if defined(EXTL_MPL_IF_SUPPORT) && \
146 defined(EXTL_TYPE_TRAITS_ADD_CONST_SUPPORT) && \
147 defined(EXTL_TYPE_TRAITS_IS_CONST_SUPPORT)
148 /// The element type
149 typedef typename_type_k EXTL_NS_MPL(if_)< (is_const<T>::value)
150 , typename_type_k add_const<old_type_>::type
151 , old_type_
152 >::type type;
153 #else
154 typedef old_type_ type;
155 #endif
156 /// The return type of element
157 typedef typename_type_k call_traits<type>::reference reference;
158 /// The const return type of element
159 typedef typename_type_k call_traits<type>::const_reference const_reference;
160 /// The parameter type of element
161 typedef typename_type_k call_traits<type>::param_type param_type;
162 /// @}
163 };
164
165 /* ///////////////////////////////////////////////////////////////////////
166 * ::extl::detail namespace
167 */
168 EXTL_DETAIL_BEGIN_NAMESPACE
169
170 // get_tuple_element implemention
171 template <e_size_t N>
172 struct get_tuple_element_impl
173 {
174 #if EXTL_WORKAROUND_MSVC(==, 1200)
175
176 template< typename_param_k T1
177 , typename_param_k T2
178 >
179 inline static typename_type_ret_k
180 tuple_element_traits< N
181 , tuple2<T1, T2>
182 >::reference
183 get(tuple2<T1, T2>& t)
184 {
185 return get_tuple_element_impl<N - 1>::get(t.get_tail());
186 }
187
188 template< typename_param_k T1
189 , typename_param_k T2
190 >
191 inline static typename_type_ret_k
192 tuple_element_traits< N
193 , tuple2<T1, T2>
194 >::const_reference
195 get(tuple2<T1, T2> const& t)
196 {
197 return get_tuple_element_impl<N - 1>::get(t.get_tail());
198 }
199
200 #else
201
202 template< typename_param_k RT
203 , typename_param_k T1
204 , typename_param_k T2
205 >
206 inline static RT get(tuple2<T1, T2> const& t)
207 {
208 return get_tuple_element_impl<N - 1>::template_qual_k get<RT>(t.get_tail());
209 }
210
211 template< typename_param_k RT
212 , typename_param_k T1
213 , typename_param_k T2
214 >
215 inline static RT get(tuple2<T1, T2>& t)
216 {
217 return get_tuple_element_impl<N - 1>::template_qual_k get<RT>(t.get_tail());
218 }
219 #endif
220 };
221 EXTL_TEMPLATE_SPECIALISATION
222 struct get_tuple_element_impl<0>
223 {
224 #if EXTL_WORKAROUND_MSVC(==, 1200)
225
226 template< typename_param_k T1
227 , typename_param_k T2
228 >
229 inline static typename_type_ret_k
230 tuple_element_traits< 0
231 , tuple2<T1, T2>
232 >::reference
233 get(tuple2<T1, T2>& t)
234 {
235 return t.get_head();
236 }
237
238 template< typename_param_k T1
239 , typename_param_k T2
240 >
241 inline static typename_type_ret_k
242 tuple_element_traits< 0
243 , tuple2<T1, T2>
244 >::const_reference
245 get(tuple2<T1, T2> const& t)
246 {
247 return t.get_head();
248 }
249 #else
250 template< typename_param_k RT
251 , typename_param_k T1
252 , typename_param_k T2
253 >
254 inline static RT get(tuple2<T1, T2> const& t)
255 {
256 return t.get_head();
257 }
258
259 template< typename_param_k RT
260 , typename_param_k T1
261 , typename_param_k T2
262 >
263 inline static RT get(tuple2<T1, T2>& t)
264 {
265 return t.get_head();
266 }
267 #endif
268 };
269
270 /* ///////////////////////////////////////////////////////////////////////
271 * ::extl::detail namespace
272 */
273 EXTL_DETAIL_END_NAMESPACE
274
275 #if EXTL_WORKAROUND_MSVC(==, 1200)
276 /*!\brief Gets the element of tuple/EXTL_NS_DETAIL(tuple2)
277 *
278 * \param N The sequence number of elements
279 * \param T1 The head type of EXTL_NS_DETAIL(tuple2)
280 * \param T2 The tail type of EXTL_NS_DETAIL(tuple2)
281 * \param t EXTL_NS_DETAIL(tuple2)<T1, T2> const&
282 *
283 * \code
284 tuple<int, void*, double> t(1, NULL, 1.5);
285 int a = get_tuple_element<0>(t);
286 get_tuple_element<0>(t) = 10;
287 * \endcode
288 *
289 * \ingroup extl_group_container
290 */
291 template< e_size_t N
292 , typename_param_k T1
293 , typename_param_k T2
294 >
295 EXTL_INLINE
296 typename_type_ret_k
297 tuple_element_traits< N
298 , EXTL_NS_DETAIL(tuple2)<T1, T2>
299 >::reference
300 get_tuple_element(EXTL_NS_DETAIL(tuple2)<T1, T2>& t EXTL_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(e_size_t, N))
301 {
302 return EXTL_NS_DETAIL(get_tuple_element_impl)<N>::get(t);
303 }
304 /*!\brief Gets the const element of tuple/EXTL_NS_DETAIL(tuple2)
305 *
306 * \param N The sequence number of elements
307 * \param T1 The head type of EXTL_NS_DETAIL(tuple2)
308 * \param T2 The tail type of EXTL_NS_DETAIL(tuple2)
309 * \param t EXTL_NS_DETAIL(tuple2)<T1, T2> const&
310 *
311 * \code
312 tuple<int, void*, double> t(1, NULL, 1.5);
313 int a = get_tuple_element<0>(t);
314 * \endcode
315 *
316 * \ingroup extl_group_container
317 */
318 template< e_size_t N
319 , typename_param_k T1
320 , typename_param_k T2
321 >
322 EXTL_INLINE
323 typename_type_ret_k
324 tuple_element_traits< N
325 , EXTL_NS_DETAIL(tuple2)<T1, T2>
326 >::const_reference
327 get_tuple_element(EXTL_NS_DETAIL(tuple2)<T1, T2> const& t EXTL_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(e_size_t, N))
328 {
329 return EXTL_NS_DETAIL(get_tuple_element_impl)<N>::get(t);
330 }
331 #else
332 /*!\brief Gets the element of tuple/EXTL_NS_DETAIL(tuple2)
333 *
334 * \param N The sequence number of elements
335 * \param T1 The head type of EXTL_NS_DETAIL(tuple2)
336 * \param T2 The tail type of EXTL_NS_DETAIL(tuple2)
337 * \param t EXTL_NS_DETAIL(tuple2)<T1, T2> const&
338 *
339 * \code
340 tuple<int, void*, double> t(1, NULL, 1.5);
341 int a = get_tuple_element<0>(t);
342 get_tuple_element<0>(t) = 10;
343 * \endcode
344 *
345 * \ingroup extl_group_container
346 */
347 template< e_size_t N
348 , typename_param_k T1
349 , typename_param_k T2
350 >
351 EXTL_INLINE
352 typename_type_ret_k
353 tuple_element_traits< N
354 , EXTL_NS_DETAIL(tuple2)<T1, T2>
355 >::reference
356 get_tuple_element(EXTL_NS_DETAIL(tuple2)<T1, T2>& t EXTL_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(e_size_t, N))
357 {
358 EXTL_STATIC_ASSERT(N < (tuple_elements_size<EXTL_NS_DETAIL(tuple2)<T1, T2> >::value));
359 return EXTL_NS_DETAIL(get_tuple_element_impl)<N>::template_qual_k
360 get < typename_type_k
361 tuple_element_traits< N
362 , EXTL_NS_DETAIL(tuple2)<T1, T2>
363 >::reference
364 , T1
365 , T2
366 >(t);
367 }
368 /*!\brief Gets the const element of tuple/EXTL_NS_DETAIL(tuple2)
369 *
370 * \param N The sequence number of elements
371 * \param T1 The head type of EXTL_NS_DETAIL(tuple2)
372 * \param T2 The tail type of EXTL_NS_DETAIL(tuple2)
373 * \param t EXTL_NS_DETAIL(tuple2)<T1, T2> const&
374 *
375 * \code
376 tuple<int, void*, double> t(1, NULL, 1.5);
377 int a = get_tuple_element<0>(t);
378 * \endcode
379 *
380 * \ingroup extl_group_container
381 */
382 template< e_size_t N
383 , typename_param_k T1
384 , typename_param_k T2
385 >
386 EXTL_INLINE
387 typename_type_ret_k
388 tuple_element_traits< N
389 , EXTL_NS_DETAIL(tuple2)<T1, T2>
390 >::const_reference
391 get_tuple_element(EXTL_NS_DETAIL(tuple2)<T1, T2> const& t EXTL_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(e_size_t, N))
392 {
393 EXTL_STATIC_ASSERT(N < (tuple_elements_size<EXTL_NS_DETAIL(tuple2)<T1, T2> >::value));
394 return EXTL_NS_DETAIL(get_tuple_element_impl)<N>::template_qual_k
395 get < typename_type_k
396 tuple_element_traits< N
397 , EXTL_NS_DETAIL(tuple2)<T1, T2>
398 >::const_reference
399 , T1
400 , T2
401 >(t);
402 }
403 #endif
404
405 /*!\brief Sets the element of tuple/EXTL_NS_DETAIL(tuple2)
406 *
407 * \param N The sequence number of elements
408 * \param T1 The head type of EXTL_NS_DETAIL(tuple2)
409 * \param T2 The tail type of EXTL_NS_DETAIL(tuple2)
410 * \param t EXTL_NS_DETAIL(tuple2)<T1, T2>&
411 * \param e The new element
412 *
413 * \code
414 tuple<int, void*, double> t(1, NULL, 1.5);
415 set_tuple_element<0>(t, 10);
416 * \endcode
417 *
418 * \ingroup extl_group_container
419 */
420 template< e_size_t N
421 , typename_param_k T1
422 , typename_param_k T2
423 >
424 EXTL_INLINE
425 void set_tuple_element( EXTL_NS_DETAIL(tuple2)<T1, T2>& t
426 , typename_type_k tuple_element_traits< N
427 , EXTL_NS_DETAIL(tuple2)<T1, T2>
428 >::param_type e
429 EXTL_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(e_size_t, N)
430 )
431 {
432 EXTL_STATIC_ASSERT(N < (tuple_elements_size<EXTL_NS_DETAIL(tuple2)<T1, T2> >::value));
433 get_tuple_element<N>(t) = e;
434 }
435
436 /*!\brief Gets the number of the elements of tuple/EXTL_NS_DETAIL(tuple2)
437 *
438 * \param T The tuple/EXTL_NS_DETAIL(tuple2) type
439 *
440 * \code
441 int num = tuple_elements_size< tuple<int, int> >::value; // num == 2
442 * \endcode
443 *
444 * \ingroup extl_group_container
445 */
446 template<typename_param_k T>
447 struct tuple_elements_size
448 {
449 EXTL_STATIC_MEMBER_CONST(e_size_t, value = 1 + tuple_elements_size< typename_type_k T::tail_type >::value);
450 };
451
452 EXTL_TEMPLATE_SPECIALISATION
453 struct tuple_elements_size<tuple<> >
454 {
455 EXTL_STATIC_MEMBER_CONST(e_size_t, value = 0);
456 };
457
458 EXTL_TEMPLATE_SPECIALISATION
459 struct tuple_elements_size<e_null_t>
460 {
461 EXTL_STATIC_MEMBER_CONST(e_size_t, value = 0);
462 };
463
464 /*!\brief tuple class
465 *
466 * \ingroup extl_group_container
467 */
468 template< typename_param_k T0
469 , typename_param_k T1
470 , typename_param_k T2
471 , typename_param_k T3
472 , typename_param_k T4
473 , typename_param_k T5
474 , typename_param_k T6
475 , typename_param_k T7
476 , typename_param_k T8
477 , typename_param_k T9
478 >
479 class tuple
480 : public EXTL_NS_DETAIL(tuple2) < T0
481 , typename_type_k tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, e_null_t>::base_type
482 >
483 {
484 private:
485 typedef typename_type_k call_traits<T0>::param_type param0_type;
486 typedef typename_type_k call_traits<T1>::param_type param1_type;
487 typedef typename_type_k call_traits<T2>::param_type param2_type;
488 typedef typename_type_k call_traits<T3>::param_type param3_type;
489 typedef typename_type_k call_traits<T4>::param_type param4_type;
490 typedef typename_type_k call_traits<T5>::param_type param5_type;
491 typedef typename_type_k call_traits<T6>::param_type param6_type;
492 typedef typename_type_k call_traits<T7>::param_type param7_type;
493 typedef typename_type_k call_traits<T8>::param_type param8_type;
494 typedef typename_type_k call_traits<T9>::param_type param9_type;
495
496 /// \name Types
497 /// @{
498 public:
499 typedef EXTL_NS_DETAIL(tuple2) < T0
500 , typename_type_k
501 tuple < T1
502 , T2
503 , T3
504 , T4
505 , T5
506 , T6
507 , T7
508 , T8
509 , T9
510 , e_null_t
511 >::base_type
512 > base_type;
513 typedef tuple class_type;
514 typedef e_size_t size_type;
515 /// @}
516
517 /// \name Constructors
518 /// @{
519 public:
520 tuple()
521 : base_type()
522 {}
523 tuple(param0_type t0)
524 : base_type(t0, cnull(), cnull(), cnull(), cnull(), cnull(), cnull(), cnull(), cnull(), cnull())
525 {}
526 tuple(param0_type t0, param1_type t1)
527 : base_type(t0, t1, cnull(), cnull(), cnull(), cnull(), cnull(), cnull(), cnull(), cnull())
528 {}
529 tuple(param0_type t0, param1_type t1, param2_type t2)
530 : base_type(t0, t1, t2, cnull(), cnull(), cnull(), cnull(), cnull(), cnull(), cnull())
531 {}
532 tuple(param0_type t0, param1_type t1, param2_type t2, param3_type t3)
533 : base_type(t0, t1, t2, t3, cnull(), cnull(), cnull(), cnull(), cnull(), cnull())
534 {}
535 tuple(param0_type t0, param1_type t1, param2_type t2, param3_type t3, param4_type t4)
536 : base_type(t0, t1, t2, t3, t4, cnull(), cnull(), cnull(), cnull(), cnull())
537 {}
538 tuple(param0_type t0, param1_type t1, param2_type t2, param3_type t3, param4_type t4, param5_type t5)
539 : base_type(t0, t1, t2, t3, t4, t5, cnull(), cnull(), cnull(), cnull())
540 {}
541 tuple(param0_type t0, param1_type t1, param2_type t2, param3_type t3, param4_type t4, param5_type t5, param6_type t6)
542 : base_type(t0, t1, t2, t3, t4, t5, t6, cnull(), cnull(), cnull())
543 {}
544 tuple(param0_type t0, param1_type t1, param2_type t2, param3_type t3, param4_type t4, param5_type t5, param6_type t6, param7_type t7)
545 : base_type(t0, t1, t2, t3, t4, t5, t6, t7, cnull(), cnull())
546 {}
547 tuple(param0_type t0, param1_type t1, param2_type t2, param3_type t3, param4_type t4, param5_type t5, param6_type t6, param7_type t7, param8_type t8)
548 : base_type(t0, t1, t2, t3, t4, t5, t6, t7, t8, cnull())
549 {}
550 tuple(param0_type t0, param1_type t1, param2_type t2, param3_type t3, param4_type t4, param5_type t5, param6_type t6, param7_type t7, param8_type t8, param9_type t9)
551 : base_type(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
552 {}
553
554 /// @}
555
556 /// \name Accessors nad Mutators
557 /// @{
558 public:
559 void swap(class_type& rhs)
560 {
561 static_cast<base_type&>(*this).swap(rhs);
562 }
563 class_type& operator =(class_type const& rhs)
564 {
565 static_cast<base_type&>(*this) = rhs;
566 return *this;
567 }
568
569 static size_type size()
570 {
571 return (tuple_elements_size<base_type>::value);
572 }
573
574 /* VC6.0 exists some bugs:
575 * bug1: t.get<0>() syntax error ')'
576 * work out bug1:
577 * declaration: get(int); call: t.get<0>(0);
578 *
579 * bug2: t.get<0>() and t.set<0>() cannot be called normally.
580 * t.get<0>() will be zero forever
581 */
582 #if defined(EXTL_MEMBER_TEMPLATE_FUNCTION_SUPPORT) && \
583 !EXTL_WORKAROUND_MSVC(==, 1200)
584 template <e_size_t N>
585 typename_type_ret_k
586 tuple_element_traits< N
587 , base_type
588 >::reference
589 get(EXTL_EXPLICIT_TEMPLATE_NON_TYPE(e_size_t, N))
590 {
591 EXTL_STATIC_ASSERT(N < (tuple_elements_size<base_type>::value));
592 return get_tuple_element<N>(*this);
593 }
594
595 template <e_size_t N>
596 typename_type_ret_k
597 tuple_element_traits< N
598 , base_type
599 >::const_reference
600 get(EXTL_EXPLICIT_TEMPLATE_NON_TYPE(e_size_t, N)) const
601 {
602 EXTL_STATIC_ASSERT(N < (tuple_elements_size<base_type>::value));
603 return get_tuple_element<N>(*this);
604 }
605
606 template <e_size_t N>
607 void set(typename_type_ret_k
608 tuple_element_traits< N
609 , base_type
610 >::param_type e
611 EXTL_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(e_size_t, N))
612 {
613 EXTL_STATIC_ASSERT(N < (tuple_elements_size<base_type>::value));
614 set_tuple_element<N>(*this, e);
615 }
616 #endif
617 /// @}
618 };
619
620
621 EXTL_TEMPLATE_SPECIALISATION
622 class tuple<e_null_t, e_null_t, e_null_t, e_null_t, e_null_t, e_null_t, e_null_t, e_null_t, e_null_t, e_null_t>
623 {
624 /// \name Types
625 /// @{
626 public:
627 typedef e_null_t base_type;
628 typedef tuple class_type;
629 typedef e_size_t size_type;
630 /// @}
631 };
632
633 /* ///////////////////////////////////////////////////////////////////////
634 * Make tuple
635 */
636 EXTL_INLINE tuple<> make_tuple()
637 {
638 return tuple<>();
639 }
640
641 template<typename_param_k T0>
642 EXTL_INLINE tuple<T0> make_tuple(T0 const& t0)
643 {
644 return tuple<T0>(t0);
645 }
646
647 template< typename_param_k T0
648 , typename_param_k T1
649 >
650 EXTL_INLINE tuple<T0, T1> make_tuple(T0 const& t0, T1 const& t1)
651 {
652 return tuple<T0, T1>(t0, t1);
653 }
654
655 template< typename_param_k T0
656 , typename_param_k T1
657 , typename_param_k T2
658 >
659 EXTL_INLINE tuple<T0, T1, T2> make_tuple(T0 const& t0, T1 const& t1, T2 const& t2)
660 {
661 return tuple<T0, T1, T2>(t0, t1, t2);
662 }
663
664 template< typename_param_k T0
665 , typename_param_k T1
666 , typename_param_k T2
667 , typename_param_k T3
668 >
669 EXTL_INLINE tuple<T0, T1, T2, T3> make_tuple(T0 const& t0, T1 const& t1, T2 const& t2, T3 const& t3)
670 {
671 return tuple<T0, T1, T2, T3>(t0, t1, t2, t3);
672 }
673
674 template< typename_param_k T0
675 , typename_param_k T1
676 , typename_param_k T2
677 , typename_param_k T3
678 , typename_param_k T4
679 >
680 EXTL_INLINE tuple<T0, T1, T2, T3, T4> make_tuple(T0 const& t0, T1 const& t1, T2 const& t2, T3 const& t3, T4 const& t4)
681 {
682 return tuple<T0, T1, T2, T3, T4>(t0, t1, t2, t3, t4);
683 }
684
685 template< typename_param_k T0
686 , typename_param_k T1
687 , typename_param_k T2
688 , typename_param_k T3
689 , typename_param_k T4
690 , typename_param_k T5
691 >
692 EXTL_INLINE tuple<T0, T1, T2, T3, T4, T5> make_tuple(T0 const& t0, T1 const& t1, T2 const& t2, T3 const& t3, T4 const& t4, T5 const& t5)
693 {
694 return tuple<T0, T1, T2, T3, T4, T5>(t0, t1, t2, t3, t4, t5);
695 }
696
697 template< typename_param_k T0
698 , typename_param_k T1
699 , typename_param_k T2
700 , typename_param_k T3
701 , typename_param_k T4
702 , typename_param_k T5
703 , typename_param_k T6
704 >
705 EXTL_INLINE tuple<T0, T1, T2, T3, T4, T5, T6> make_tuple(T0 const& t0, T1 const& t1, T2 const& t2, T3 const& t3, T4 const& t4, T5 const& t5, T6 const& t6)
706 {
707 return tuple<T0, T1, T2, T3, T4, T5, T6>(t0, t1, t2, t3, t4, t5, t6);
708 }
709
710 template< typename_param_k T0
711 , typename_param_k T1
712 , typename_param_k T2
713 , typename_param_k T3
714 , typename_param_k T4
715 , typename_param_k T5
716 , typename_param_k T6
717 , typename_param_k T7
718 >
719 EXTL_INLINE tuple<T0, T1, T2, T3, T4, T5, T6, T7> make_tuple(T0 const& t0, T1 const& t1, T2 const& t2, T3 const& t3, T4 const& t4, T5 const& t5, T6 const& t6, T7 const& t7)
720 {
721 return tuple<T0, T1, T2, T3, T4, T5, T6, T7>(t0, t1, t2, t3, t4, t5, t6, t7);
722 }
723
724 template< typename_param_k T0
725 , typename_param_k T1
726 , typename_param_k T2
727 , typename_param_k T3
728 , typename_param_k T4
729 , typename_param_k T5
730 , typename_param_k T6
731 , typename_param_k T7
732 , typename_param_k T8
733 >
734 EXTL_INLINE tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8> make_tuple(T0 const& t0, T1 const& t1, T2 const& t2, T3 const& t3, T4 const& t4, T5 const& t5, T6 const& t6, T7 const& t7, T8 const& t8)
735 {
736 return tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8>(t0, t1, t2, t3, t4, t5, t6, t7, t8);
737 }
738
739 template< typename_param_k T0
740 , typename_param_k T1
741 , typename_param_k T2
742 , typename_param_k T3
743 , typename_param_k T4
744 , typename_param_k T5
745 , typename_param_k T6
746 , typename_param_k T7
747 , typename_param_k T8
748 , typename_param_k T9
749 >
750 EXTL_INLINE tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> make_tuple(T0 const& t0, T1 const& t1, T2 const& t2, T3 const& t3, T4 const& t4, T5 const& t5, T6 const& t6, T7 const& t7, T8 const& t8, T9 const& t9)
751 {
752 return tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
753 }
754
755 /* /////////////////////////////////////////////////////////////////////////
756 * swapping
757 */
758 template< typename_param_k T1
759 , typename_param_k T2
760 >
761 EXTL_INLINE void swap(EXTL_NS_DETAIL(tuple2)<T1, T2> &lhs, EXTL_NS_DETAIL(tuple2)<T1, T2> &rhs)
762 {
763 lhs.swap(rhs);
764 }
765
766
767 /* ///////////////////////////////////////////////////////////////////////
768 * ::extl namespace
769 */
770 EXTL_END_NAMESPACE
771
772 /* ///////////////////////////////////////////////////////////////////////
773 * std::swap
774 */
775 #if !defined(EXTL_NO_STL) && \
776 !defined(EXTL_NO_NAMESPACE)
777 /* ::std namespace */
778 EXTL_STD_BEGIN_NAMESPACE
779
780 template< typename_param_k T1
781 , typename_param_k T2
782 >
783 EXTL_INLINE void swap(EXTL_NS(EXTL_NS_DETAIL(tuple2))<T1, T2>& lhs, EXTL_NS(EXTL_NS_DETAIL(tuple2))<T1, T2>& rhs)
784 {
785 lhs.swap(rhs);
786 }
787 /* ::std namespace */
788 EXTL_STD_END_NAMESPACE
789 #endif
790
791 /* //////////////////////////////////////////////////////////////////// */
792 #endif /* EXTL_CONTAINER_DETAIL_TUPLE_IMPL_H */
793 /* //////////////////////////////////////////////////////////////////// */
a c++ generic library