00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 #ifndef _GLIBCXX_TUPLE
00030 #define _GLIBCXX_TUPLE 1
00031
00032 #pragma GCC system_header
00033
00034 #ifndef __GXX_EXPERIMENTAL_CXX0X__
00035 # include <c++0x_warning.h>
00036 #else
00037
00038 #include <utility>
00039
00040 namespace std
00041 {
00042
00043 template<typename _Tp>
00044 struct __add_c_ref
00045 { typedef const _Tp& type; };
00046
00047 template<typename _Tp>
00048 struct __add_c_ref<_Tp&>
00049 { typedef _Tp& type; };
00050
00051
00052 template<typename _Tp>
00053 struct __add_ref
00054 { typedef _Tp& type; };
00055
00056 template<typename _Tp>
00057 struct __add_ref<_Tp&>
00058 { typedef _Tp& type; };
00059
00060 template<std::size_t _Idx, typename _Head, bool _IsEmpty>
00061 struct _Head_base;
00062
00063 template<std::size_t _Idx, typename _Head>
00064 struct _Head_base<_Idx, _Head, true>
00065 : public _Head
00066 {
00067 _Head_base()
00068 : _Head() { }
00069
00070 _Head_base(const _Head& __h)
00071 : _Head(__h) { }
00072
00073 template<typename _UHead>
00074 _Head_base(_UHead&& __h)
00075 : _Head(std::forward<_UHead>(__h)) { }
00076
00077 _Head& _M_head() { return *this; }
00078 const _Head& _M_head() const { return *this; }
00079
00080 void _M_swap_impl(_Head&&) { }
00081 };
00082
00083 template<std::size_t _Idx, typename _Head>
00084 struct _Head_base<_Idx, _Head, false>
00085 {
00086 _Head_base()
00087 : _M_head_impl() { }
00088
00089 _Head_base(const _Head& __h)
00090 : _M_head_impl(__h) { }
00091
00092 template<typename _UHead>
00093 _Head_base(_UHead&& __h)
00094 : _M_head_impl(std::forward<_UHead>(__h)) { }
00095
00096 _Head& _M_head() { return _M_head_impl; }
00097 const _Head& _M_head() const { return _M_head_impl; }
00098
00099 void
00100 _M_swap_impl(_Head&& __h)
00101 {
00102 using std::swap;
00103 swap(__h, _M_head_impl);
00104 }
00105
00106 _Head _M_head_impl;
00107 };
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117 template<std::size_t _Idx, typename... _Elements>
00118 struct _Tuple_impl;
00119
00120
00121
00122
00123
00124 template<std::size_t _Idx>
00125 struct _Tuple_impl<_Idx>
00126 {
00127 protected:
00128 void _M_swap_impl(_Tuple_impl&&) { }
00129 };
00130
00131
00132
00133
00134
00135
00136 template<std::size_t _Idx, typename _Head, typename... _Tail>
00137 struct _Tuple_impl<_Idx, _Head, _Tail...>
00138 : public _Tuple_impl<_Idx + 1, _Tail...>,
00139 private _Head_base<_Idx, _Head, std::is_empty<_Head>::value>
00140 {
00141 typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
00142 typedef _Head_base<_Idx, _Head, std::is_empty<_Head>::value> _Base;
00143
00144 _Head& _M_head() { return _Base::_M_head(); }
00145 const _Head& _M_head() const { return _Base::_M_head(); }
00146
00147 _Inherited& _M_tail() { return *this; }
00148 const _Inherited& _M_tail() const { return *this; }
00149
00150 _Tuple_impl()
00151 : _Inherited(), _Base() { }
00152
00153 explicit
00154 _Tuple_impl(const _Head& __head, const _Tail&... __tail)
00155 : _Inherited(__tail...), _Base(__head) { }
00156
00157 template<typename _UHead, typename... _UTail>
00158 explicit
00159 _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
00160 : _Inherited(std::forward<_UTail>(__tail)...),
00161 _Base(std::forward<_UHead>(__head)) { }
00162
00163 _Tuple_impl(const _Tuple_impl& __in)
00164 : _Inherited(__in._M_tail()), _Base(__in._M_head()) { }
00165
00166 _Tuple_impl(_Tuple_impl&& __in)
00167 : _Inherited(std::move<_Inherited&&>(__in._M_tail())),
00168 _Base(std::forward<_Head>(__in._M_head())) { }
00169
00170 template<typename... _UElements>
00171 _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
00172 : _Inherited(__in._M_tail()), _Base(__in._M_head()) { }
00173
00174 template<typename... _UElements>
00175 _Tuple_impl(_Tuple_impl<_Idx, _UElements...>&& __in)
00176 : _Inherited(std::move<typename _Tuple_impl<_Idx, _UElements...>::
00177 _Inherited&&>(__in._M_tail())),
00178 _Base(std::forward<typename _Tuple_impl<_Idx, _UElements...>::
00179 _Base>(__in._M_head())) { }
00180
00181 _Tuple_impl&
00182 operator=(const _Tuple_impl& __in)
00183 {
00184 _M_head() = __in._M_head();
00185 _M_tail() = __in._M_tail();
00186 return *this;
00187 }
00188
00189 _Tuple_impl&
00190 operator=(_Tuple_impl&& __in)
00191 {
00192 _M_head() = std::move(__in._M_head());
00193 _M_tail() = std::move(__in._M_tail());
00194 return *this;
00195 }
00196
00197 template<typename... _UElements>
00198 _Tuple_impl&
00199 operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
00200 {
00201 _M_head() = __in._M_head();
00202 _M_tail() = __in._M_tail();
00203 return *this;
00204 }
00205
00206 template<typename... _UElements>
00207 _Tuple_impl&
00208 operator=(_Tuple_impl<_Idx, _UElements...>&& __in)
00209 {
00210 _M_head() = std::move(__in._M_head());
00211 _M_tail() = std::move(__in._M_tail());
00212 return *this;
00213 }
00214
00215 protected:
00216 void
00217 _M_swap_impl(_Tuple_impl&& __in)
00218 {
00219 _Base::_M_swap_impl(__in._M_head());
00220 _Inherited::_M_swap_impl(__in._M_tail());
00221 }
00222 };
00223
00224
00225 template<typename... _Elements>
00226 class tuple : public _Tuple_impl<0, _Elements...>
00227 {
00228 typedef _Tuple_impl<0, _Elements...> _Inherited;
00229
00230 public:
00231 tuple()
00232 : _Inherited() { }
00233
00234 explicit
00235 tuple(const _Elements&... __elements)
00236 : _Inherited(__elements...) { }
00237
00238 template<typename... _UElements>
00239 explicit
00240 tuple(_UElements&&... __elements)
00241 : _Inherited(std::forward<_UElements>(__elements)...) { }
00242
00243 tuple(const tuple& __in)
00244 : _Inherited(static_cast<const _Inherited&>(__in)) { }
00245
00246 tuple(tuple&& __in)
00247 : _Inherited(std::move<_Inherited>(__in)) { }
00248
00249 template<typename... _UElements>
00250 tuple(const tuple<_UElements...>& __in)
00251 : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
00252 { }
00253
00254 template<typename... _UElements>
00255 tuple(tuple<_UElements...>&& __in)
00256 : _Inherited(std::move<_Tuple_impl<0, _UElements...> >(__in)) { }
00257
00258
00259 template<typename... _UElements>
00260 tuple(tuple<_UElements...>& __in)
00261 : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
00262 { }
00263
00264 tuple&
00265 operator=(const tuple& __in)
00266 {
00267 static_cast<_Inherited&>(*this) = __in;
00268 return *this;
00269 }
00270
00271 tuple&
00272 operator=(tuple&& __in)
00273 {
00274 static_cast<_Inherited&>(*this) = std::move(__in);
00275 return *this;
00276 }
00277
00278 template<typename... _UElements>
00279 tuple&
00280 operator=(const tuple<_UElements...>& __in)
00281 {
00282 static_cast<_Inherited&>(*this) = __in;
00283 return *this;
00284 }
00285
00286 template<typename... _UElements>
00287 tuple&
00288 operator=(tuple<_UElements...>&& __in)
00289 {
00290 static_cast<_Inherited&>(*this) = std::move(__in);
00291 return *this;
00292 }
00293
00294 void
00295 swap(tuple&& __in)
00296 { _Inherited::_M_swap_impl(__in); }
00297 };
00298
00299
00300 template<>
00301 class tuple<>
00302 {
00303 public:
00304 void swap(tuple&&) { }
00305 };
00306
00307
00308 template<typename _T1, typename _T2>
00309 class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
00310 {
00311 typedef _Tuple_impl<0, _T1, _T2> _Inherited;
00312
00313 public:
00314 tuple()
00315 : _Inherited() { }
00316
00317 explicit
00318 tuple(const _T1& __a1, const _T2& __a2)
00319 : _Inherited(__a1, __a2) { }
00320
00321 template<typename _U1, typename _U2>
00322 explicit
00323 tuple(_U1&& __a1, _U2&& __a2)
00324 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
00325
00326 tuple(const tuple& __in)
00327 : _Inherited(static_cast<const _Inherited&>(__in)) { }
00328
00329 tuple(tuple&& __in)
00330 : _Inherited(std::move<_Inherited>(__in)) { }
00331
00332 template<typename _U1, typename _U2>
00333 tuple(const tuple<_U1, _U2>& __in)
00334 : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
00335
00336 template<typename _U1, typename _U2>
00337 tuple(tuple<_U1, _U2>&& __in)
00338 : _Inherited(std::move<_Tuple_impl<0, _U1, _U2> >(__in)) { }
00339
00340 template<typename _U1, typename _U2>
00341 tuple(const pair<_U1, _U2>& __in)
00342 : _Inherited(__in.first, __in.second) { }
00343
00344 template<typename _U1, typename _U2>
00345 tuple(pair<_U1, _U2>&& __in)
00346 : _Inherited(std::move(__in.first), std::move(__in.second)) { }
00347
00348 tuple&
00349 operator=(const tuple& __in)
00350 {
00351 static_cast<_Inherited&>(*this) = __in;
00352 return *this;
00353 }
00354
00355 tuple&
00356 operator=(tuple&& __in)
00357 {
00358 static_cast<_Inherited&>(*this) = std::move(__in);
00359 return *this;
00360 }
00361
00362 template<typename _U1, typename _U2>
00363 tuple&
00364 operator=(const tuple<_U1, _U2>& __in)
00365 {
00366 static_cast<_Inherited&>(*this) = __in;
00367 return *this;
00368 }
00369
00370 template<typename _U1, typename _U2>
00371 tuple&
00372 operator=(tuple<_U1, _U2>&& __in)
00373 {
00374 static_cast<_Inherited&>(*this) = std::move(__in);
00375 return *this;
00376 }
00377
00378 template<typename _U1, typename _U2>
00379 tuple&
00380 operator=(const pair<_U1, _U2>& __in)
00381 {
00382 this->_M_head() = __in.first;
00383 this->_M_tail()._M_head() = __in.second;
00384 return *this;
00385 }
00386
00387 template<typename _U1, typename _U2>
00388 tuple&
00389 operator=(pair<_U1, _U2>&& __in)
00390 {
00391 this->_M_head() = std::move(__in.first);
00392 this->_M_tail()._M_head() = std::move(__in.second);
00393 return *this;
00394 }
00395
00396 void
00397 swap(tuple&& __in)
00398 {
00399 using std::swap;
00400 swap(this->_M_head(), __in._M_head());
00401 swap(this->_M_tail()._M_head(), __in._M_tail()._M_head());
00402 }
00403 };
00404
00405
00406
00407 template<std::size_t __i, typename _Tp>
00408 struct tuple_element;
00409
00410
00411
00412
00413
00414 template<std::size_t __i, typename _Head, typename... _Tail>
00415 struct tuple_element<__i, tuple<_Head, _Tail...> >
00416 : tuple_element<__i - 1, tuple<_Tail...> > { };
00417
00418
00419
00420
00421 template<typename _Head, typename... _Tail>
00422 struct tuple_element<0, tuple<_Head, _Tail...> >
00423 {
00424 typedef _Head type;
00425 };
00426
00427
00428 template<typename _Tp>
00429 struct tuple_size;
00430
00431
00432 template<typename... _Elements>
00433 struct tuple_size<tuple<_Elements...> >
00434 {
00435 static const std::size_t value = sizeof...(_Elements);
00436 };
00437
00438 template<typename... _Elements>
00439 const std::size_t tuple_size<tuple<_Elements...> >::value;
00440
00441 template<std::size_t __i, typename _Head, typename... _Tail>
00442 inline typename __add_ref<_Head>::type
00443 __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t)
00444 { return __t._M_head(); }
00445
00446 template<std::size_t __i, typename _Head, typename... _Tail>
00447 inline typename __add_c_ref<_Head>::type
00448 __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t)
00449 { return __t._M_head(); }
00450
00451
00452
00453 template<std::size_t __i, typename... _Elements>
00454 inline typename __add_ref<
00455 typename tuple_element<__i, tuple<_Elements...> >::type
00456 >::type
00457 get(tuple<_Elements...>& __t)
00458 { return __get_helper<__i>(__t); }
00459
00460 template<std::size_t __i, typename... _Elements>
00461 inline typename __add_c_ref<
00462 typename tuple_element<__i, tuple<_Elements...> >::type
00463 >::type
00464 get(const tuple<_Elements...>& __t)
00465 { return __get_helper<__i>(__t); }
00466
00467
00468 template<std::size_t __check_equal_size, std::size_t __i, std::size_t __j,
00469 typename _Tp, typename _Up>
00470 struct __tuple_compare;
00471
00472 template<std::size_t __i, std::size_t __j, typename _Tp, typename _Up>
00473 struct __tuple_compare<0, __i, __j, _Tp, _Up>
00474 {
00475 static bool __eq(const _Tp& __t, const _Up& __u)
00476 {
00477 return (get<__i>(__t) == get<__i>(__u) &&
00478 __tuple_compare<0, __i + 1, __j, _Tp, _Up>::__eq(__t, __u));
00479 }
00480
00481 static bool __less(const _Tp& __t, const _Up& __u)
00482 {
00483 return ((get<__i>(__t) < get<__i>(__u))
00484 || !(get<__i>(__u) < get<__i>(__t)) &&
00485 __tuple_compare<0, __i + 1, __j, _Tp, _Up>::__less(__t, __u));
00486 }
00487 };
00488
00489 template<std::size_t __i, typename _Tp, typename _Up>
00490 struct __tuple_compare<0, __i, __i, _Tp, _Up>
00491 {
00492 static bool __eq(const _Tp&, const _Up&)
00493 { return true; }
00494
00495 static bool __less(const _Tp&, const _Up&)
00496 { return false; }
00497 };
00498
00499 template<typename... _TElements, typename... _UElements>
00500 bool
00501 operator==(const tuple<_TElements...>& __t,
00502 const tuple<_UElements...>& __u)
00503 {
00504 typedef tuple<_TElements...> _Tp;
00505 typedef tuple<_UElements...> _Up;
00506 return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
00507 0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
00508 }
00509
00510 template<typename... _TElements, typename... _UElements>
00511 bool
00512 operator<(const tuple<_TElements...>& __t,
00513 const tuple<_UElements...>& __u)
00514 {
00515 typedef tuple<_TElements...> _Tp;
00516 typedef tuple<_UElements...> _Up;
00517 return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
00518 0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
00519 }
00520
00521 template<typename... _TElements, typename... _UElements>
00522 inline bool
00523 operator!=(const tuple<_TElements...>& __t,
00524 const tuple<_UElements...>& __u)
00525 { return !(__t == __u); }
00526
00527 template<typename... _TElements, typename... _UElements>
00528 inline bool
00529 operator>(const tuple<_TElements...>& __t,
00530 const tuple<_UElements...>& __u)
00531 { return __u < __t; }
00532
00533 template<typename... _TElements, typename... _UElements>
00534 inline bool
00535 operator<=(const tuple<_TElements...>& __t,
00536 const tuple<_UElements...>& __u)
00537 { return !(__u < __t); }
00538
00539 template<typename... _TElements, typename... _UElements>
00540 inline bool
00541 operator>=(const tuple<_TElements...>& __t,
00542 const tuple<_UElements...>& __u)
00543 { return !(__t < __u); }
00544
00545
00546 template<typename... _Elements>
00547 inline tuple<typename __decay_and_strip<_Elements>::__type...>
00548 make_tuple(_Elements&&... __args)
00549 {
00550 typedef tuple<typename __decay_and_strip<_Elements>::__type...>
00551 __result_type;
00552 return __result_type(std::forward<_Elements>(__args)...);
00553 }
00554
00555 template<std::size_t...> struct __index_holder { };
00556
00557 template<std::size_t __i, typename _IdxHolder, typename... _Elements>
00558 struct __index_holder_impl;
00559
00560 template<std::size_t __i, std::size_t... _Indexes, typename _IdxHolder,
00561 typename... _Elements>
00562 struct __index_holder_impl<__i, __index_holder<_Indexes...>,
00563 _IdxHolder, _Elements...>
00564 {
00565 typedef typename __index_holder_impl<__i + 1,
00566 __index_holder<_Indexes..., __i>,
00567 _Elements...>::type type;
00568 };
00569
00570 template<std::size_t __i, std::size_t... _Indexes>
00571 struct __index_holder_impl<__i, __index_holder<_Indexes...> >
00572 { typedef __index_holder<_Indexes...> type; };
00573
00574 template<typename... _Elements>
00575 struct __make_index_holder
00576 : __index_holder_impl<0, __index_holder<>, _Elements...> { };
00577
00578 template<typename... _TElements, std::size_t... _TIdx,
00579 typename... _UElements, std::size_t... _UIdx>
00580 inline tuple<_TElements..., _UElements...>
00581 __tuple_cat_helper(const tuple<_TElements...>& __t,
00582 const __index_holder<_TIdx...>&,
00583 const tuple<_UElements...>& __u,
00584 const __index_holder<_UIdx...>&)
00585 { return tuple<_TElements..., _UElements...>(get<_TIdx>(__t)...,
00586 get<_UIdx>(__u)...); }
00587
00588 template<typename... _TElements, std::size_t... _TIdx,
00589 typename... _UElements, std::size_t... _UIdx>
00590 inline tuple<_TElements..., _UElements...>
00591 __tuple_cat_helper(tuple<_TElements...>&& __t,
00592 const __index_holder<_TIdx...>&,
00593 const tuple<_UElements...>& __u,
00594 const __index_holder<_UIdx...>&)
00595 { return tuple<_TElements..., _UElements...>
00596 (std::move(get<_TIdx>(__t))..., get<_UIdx>(__u)...); }
00597
00598 template<typename... _TElements, std::size_t... _TIdx,
00599 typename... _UElements, std::size_t... _UIdx>
00600 inline tuple<_TElements..., _UElements...>
00601 __tuple_cat_helper(const tuple<_TElements...>& __t,
00602 const __index_holder<_TIdx...>&,
00603 tuple<_UElements...>&& __u,
00604 const __index_holder<_UIdx...>&)
00605 { return tuple<_TElements..., _UElements...>
00606 (get<_TIdx>(__t)..., std::move(get<_UIdx>(__u))...); }
00607
00608 template<typename... _TElements, std::size_t... _TIdx,
00609 typename... _UElements, std::size_t... _UIdx>
00610 inline tuple<_TElements..., _UElements...>
00611 __tuple_cat_helper(tuple<_TElements...>&& __t,
00612 const __index_holder<_TIdx...>&,
00613 tuple<_UElements...>&& __u,
00614 const __index_holder<_UIdx...>&)
00615 { return tuple<_TElements..., _UElements...>
00616 (std::move(get<_TIdx>(__t))..., std::move(get<_UIdx>(__u))...); }
00617
00618 template<typename... _TElements, typename... _UElements>
00619 inline tuple<_TElements..., _UElements...>
00620 tuple_cat(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u)
00621 {
00622 return __tuple_cat_helper(__t, typename
00623 __make_index_holder<_TElements...>::type(),
00624 __u, typename
00625 __make_index_holder<_UElements...>::type());
00626 }
00627
00628 template<typename... _TElements, typename... _UElements>
00629 inline tuple<_TElements..., _UElements...>
00630 tuple_cat(tuple<_TElements...>&& __t, const tuple<_UElements...>& __u)
00631 {
00632 return __tuple_cat_helper(std::move(__t), typename
00633 __make_index_holder<_TElements...>::type(),
00634 __u, typename
00635 __make_index_holder<_UElements...>::type());
00636 }
00637
00638 template<typename... _TElements, typename... _UElements>
00639 inline tuple<_TElements..., _UElements...>
00640 tuple_cat(const tuple<_TElements...>& __t, tuple<_UElements...>&& __u)
00641 {
00642 return __tuple_cat_helper(__t, typename
00643 __make_index_holder<_TElements...>::type(),
00644 std::move(__u), typename
00645 __make_index_holder<_UElements...>::type());
00646 }
00647
00648 template<typename... _TElements, typename... _UElements>
00649 inline tuple<_TElements..., _UElements...>
00650 tuple_cat(tuple<_TElements...>&& __t, tuple<_UElements...>&& __u)
00651 {
00652 return __tuple_cat_helper(std::move(__t), typename
00653 __make_index_holder<_TElements...>::type(),
00654 std::move(__u), typename
00655 __make_index_holder<_UElements...>::type());
00656 }
00657
00658 template<typename... _Elements>
00659 inline tuple<_Elements&...>
00660 tie(_Elements&... __args)
00661 { return tuple<_Elements&...>(__args...); }
00662
00663 template<typename... _Elements>
00664 inline void
00665 swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
00666 { __x.swap(__y); }
00667
00668 template<typename... _Elements>
00669 inline void
00670 swap(tuple<_Elements...>&& __x, tuple<_Elements...>& __y)
00671 { __x.swap(__y); }
00672
00673 template<typename... _Elements>
00674 inline void
00675 swap(tuple<_Elements...>& __x, tuple<_Elements...>&& __y)
00676 { __x.swap(__y); }
00677
00678
00679
00680 struct _Swallow_assign
00681 {
00682 template<class _Tp>
00683 _Swallow_assign&
00684 operator=(const _Tp&)
00685 { return *this; }
00686 };
00687
00688
00689 namespace
00690 {
00691 _Swallow_assign ignore;
00692 };
00693 }
00694
00695 #endif // __GXX_EXPERIMENTAL_CXX0X__
00696
00697 #endif // _GLIBCXX_TUPLE