← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to system/include/libcxx/tuple

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-09-20 22:44:35 UTC
  • mfrom: (4.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20130920224435-apuwj4fsl3fqv1a6
Tags: 1.5.6~20130920~6010666-1
http://bugs.debian.org/723129
* New snapshot release
* Update the list of supported architectures to the same as libv8
  (Closes: #723129)
* emlibtool has been removed from upstream.
* Fix warning syntax-error-in-dep5-copyright
* Refresh of the patches

Show diffs side-by-side

added added

removed removed

Lines of Context:
system/include/libcxx/tuple
21
21
class tuple {
22
22
public:
23
23
    constexpr tuple();
24
 
    explicit tuple(const T&...);
 
24
    explicit tuple(const T&...);  // constexpr in C++14
25
25
    template <class... U>
26
 
        explicit tuple(U&&...);
 
26
        explicit tuple(U&&...);  // constexpr in C++14
27
27
    tuple(const tuple&) = default;
28
28
    tuple(tuple&&) = default;
29
29
    template <class... U>
30
 
        tuple(const tuple<U...>&);
 
30
        tuple(const tuple<U...>&);  // constexpr in C++14
31
31
    template <class... U>
32
 
        tuple(tuple<U...>&&);
33
 
    template <class U1, class U2>
34
 
        tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2
35
 
    template <class U1, class U2>
36
 
        tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2
 
32
        tuple(tuple<U...>&&);  // constexpr in C++14
 
33
    template <class U1, class U2>
 
34
        tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++14
 
35
    template <class U1, class U2>
 
36
        tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2  // constexpr in C++14
37
37
 
38
38
    // allocator-extended constructors
39
39
    template <class Alloc>
72
72
 
73
73
const unspecified ignore;
74
74
 
75
 
template <class... T> tuple<V...>  make_tuple(T&&...);
 
75
template <class... T> tuple<V...>  make_tuple(T&&...); // constexpr in C++14
76
76
template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept;
77
77
template <class... T> tuple<T&...> tie(T&...) noexcept;
78
 
template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls);
 
78
template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls); // constexpr in C++14
79
79
  
80
80
// 20.4.1.4, tuple helper classes:
81
81
template <class T> class tuple_size; // undefined
86
86
// 20.4.1.5, element access:
87
87
template <intsize_t I, class... T>
88
88
    typename tuple_element<I, tuple<T...>>::type&
89
 
    get(tuple<T...>&) noexcept;
 
89
    get(tuple<T...>&) noexcept; // constexpr in C++14
90
90
template <intsize_t I, class... T>
91
91
    typename tuple_element<I, tuple<T...>>::type const&
92
 
    get(const tuple<T...>&) noexcept;
 
92
    get(const tuple<T...>&) noexcept; // constexpr in C++14
93
93
template <intsize_t I, class... T>
94
94
    typename tuple_element<I, tuple<T...>>::type&&
95
 
    get(tuple<T...>&&) noexcept;
 
95
    get(tuple<T...>&&) noexcept; // constexpr in C++14
 
96
 
 
97
template <class T1, class... T>
 
98
    constexpr T1& get(tuple<T...>&) noexcept;  // C++14
 
99
template <class T1, class... T>
 
100
    constexpr T1 const& get(const tuple<T...>&) noexcept;   // C++14
 
101
template <class T1, class... T>
 
102
    constexpr T1&& get(tuple<T...>&&) noexcept;   // C++14
96
103
 
97
104
// 20.4.1.6, relational operators:
98
 
template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&);
99
 
template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&);
100
 
template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&);
101
 
template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&);
102
 
template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&);
103
 
template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&);
 
105
template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
 
106
template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&);  // constexpr in C++14
 
107
template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
 
108
template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&);  // constexpr in C++14
 
109
template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
 
110
template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
104
111
 
105
112
template <class... Types, class Alloc>
106
113
  struct uses_allocator<tuple<Types...>, Alloc>;
259
266
 
260
267
    template <class _Tp,
261
268
              class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
262
 
        _LIBCPP_INLINE_VISIBILITY
 
269
        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
263
270
        explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
264
271
            : value(_VSTD::forward<_Tp>(__t))
265
272
        {static_assert(!is_reference<_Hp>::value ||
316
323
                                >::value)),
317
324
       "Attempted to construct a reference element in a tuple with an rvalue");}
318
325
 
 
326
    _LIBCPP_INLINE_VISIBILITY
 
327
    _LIBCPP_CONSTEXPR_AFTER_CXX11
319
328
    __tuple_leaf(const __tuple_leaf& __t) _NOEXCEPT_(is_nothrow_copy_constructible<_Hp>::value)
320
329
        : value(__t.get())
321
330
        {static_assert(!is_rvalue_reference<_Hp>::value, "Can not copy a tuple with rvalue reference member");}
322
331
 
323
 
    template <class _Tp>
324
 
        _LIBCPP_INLINE_VISIBILITY
325
 
        explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t)
326
 
                           _NOEXCEPT_((is_nothrow_constructible<_Hp, const _Tp&>::value))
327
 
            : value(__t.get()) {}
 
332
    _LIBCPP_INLINE_VISIBILITY
 
333
    _LIBCPP_CONSTEXPR_AFTER_CXX11
 
334
    __tuple_leaf(__tuple_leaf&& __t) _NOEXCEPT_(is_nothrow_move_constructible<_Hp>::value)
 
335
        : value(_VSTD::move(__t.get()))
 
336
        {}
328
337
 
329
338
    template <class _Tp>
330
339
        _LIBCPP_INLINE_VISIBILITY
342
351
        return 0;
343
352
    }
344
353
 
345
 
    _LIBCPP_INLINE_VISIBILITY       _Hp& get()       _NOEXCEPT {return value;}
346
 
    _LIBCPP_INLINE_VISIBILITY const _Hp& get() const _NOEXCEPT {return value;}
 
354
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11       _Hp& get()       _NOEXCEPT {return value;}
 
355
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return value;}
347
356
};
348
357
 
349
358
template <size_t _Ip, class _Hp>
372
381
 
373
382
    template <class _Tp,
374
383
              class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
375
 
        _LIBCPP_INLINE_VISIBILITY
 
384
        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
376
385
        explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
377
386
            : _Hp(_VSTD::forward<_Tp>(__t)) {}
378
387
 
393
402
 
394
403
    template <class _Tp>
395
404
        _LIBCPP_INLINE_VISIBILITY
396
 
        explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t)
397
 
            _NOEXCEPT_((is_nothrow_constructible<_Hp, const _Tp&>::value))
398
 
            : _Hp(__t.get()) {}
399
 
 
400
 
    template <class _Tp>
401
 
        _LIBCPP_INLINE_VISIBILITY
402
405
        __tuple_leaf&
403
406
        operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
404
407
        {
414
417
        return 0;
415
418
    }
416
419
 
417
 
    _LIBCPP_INLINE_VISIBILITY       _Hp& get()       _NOEXCEPT {return static_cast<_Hp&>(*this);}
418
 
    _LIBCPP_INLINE_VISIBILITY const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
 
420
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11       _Hp& get()       _NOEXCEPT {return static_cast<_Hp&>(*this);}
 
421
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
419
422
};
420
423
 
421
424
template <class ..._Tp>
450
453
 
451
454
    template <size_t ..._Uf, class ..._Tf,
452
455
              size_t ..._Ul, class ..._Tl, class ..._Up>
453
 
        _LIBCPP_INLINE_VISIBILITY
 
456
        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
454
457
        explicit
455
458
        __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
456
459
                     __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
477
480
    template <class _Tuple,
478
481
              class = typename enable_if
479
482
                      <
480
 
                         __tuple_convertible<_Tuple, tuple<_Tp...> >::value
 
483
                         __tuple_constructible<_Tuple, tuple<_Tp...> >::value
481
484
                      >::type
482
485
             >
483
 
        _LIBCPP_INLINE_VISIBILITY
 
486
        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
484
487
        __tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_constructible<_Tp, typename tuple_element<_Indx,
485
488
                                       typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
486
489
            : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
539
542
 
540
543
    base base_;
541
544
 
542
 
    template <size_t _Jp, class ..._Up> friend
 
545
    template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
543
546
        typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
544
 
    template <size_t _Jp, class ..._Up> friend
 
547
    template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
545
548
        const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT;
546
 
    template <size_t _Jp, class ..._Up> friend
 
549
    template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
547
550
        typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
548
551
public:
549
552
 
551
554
    _LIBCPP_CONSTEXPR tuple()
552
555
        _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
553
556
 
554
 
    _LIBCPP_INLINE_VISIBILITY
 
557
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
555
558
    explicit tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value)) 
556
559
        : base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
557
560
                typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
586
589
                         bool
587
590
                      >::type = false
588
591
             >
589
 
        _LIBCPP_INLINE_VISIBILITY
 
592
        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
590
593
        tuple(_Up&&... __u)
591
594
            _NOEXCEPT_((
592
595
                is_nothrow_constructible<
626
629
                         bool
627
630
                      >::type =false
628
631
             >
629
 
        _LIBCPP_INLINE_VISIBILITY
 
632
        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
630
633
        explicit
631
634
        tuple(_Up&&... __u)
632
635
            _NOEXCEPT_((
674
677
                         bool
675
678
                      >::type = false
676
679
             >
677
 
        _LIBCPP_INLINE_VISIBILITY
 
680
        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
678
681
        tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
679
682
            : base_(_VSTD::forward<_Tuple>(__t)) {}
680
683
 
686
689
                         bool
687
690
                      >::type = false
688
691
             >
689
 
        _LIBCPP_INLINE_VISIBILITY
 
692
        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
690
693
        explicit
691
694
        tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
692
695
            : base_(_VSTD::forward<_Tuple>(__t)) {}
756
759
// get
757
760
 
758
761
template <size_t _Ip, class ..._Tp>
759
 
inline _LIBCPP_INLINE_VISIBILITY
 
762
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
760
763
typename tuple_element<_Ip, tuple<_Tp...> >::type&
761
764
get(tuple<_Tp...>& __t) _NOEXCEPT
762
765
{
765
768
}
766
769
 
767
770
template <size_t _Ip, class ..._Tp>
768
 
inline _LIBCPP_INLINE_VISIBILITY
 
771
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
769
772
const typename tuple_element<_Ip, tuple<_Tp...> >::type&
770
773
get(const tuple<_Tp...>& __t) _NOEXCEPT
771
774
{
774
777
}
775
778
 
776
779
template <size_t _Ip, class ..._Tp>
777
 
inline _LIBCPP_INLINE_VISIBILITY
 
780
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
778
781
typename tuple_element<_Ip, tuple<_Tp...> >::type&&
779
782
get(tuple<_Tp...>&& __t) _NOEXCEPT
780
783
{
783
786
             static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get());
784
787
}
785
788
 
 
789
#if _LIBCPP_STD_VER > 11
 
790
// get by type
 
791
template <typename _T1, size_t _Idx, typename... _Args>
 
792
struct __find_exactly_one_t_helper;
 
793
 
 
794
// -- find exactly one
 
795
template <typename _T1, size_t _Idx, typename... _Args>
 
796
struct __find_exactly_one_t_checker {
 
797
    static constexpr size_t value = _Idx;
 
798
//  Check the rest of the list to make sure there's only one
 
799
    static_assert ( __find_exactly_one_t_helper<_T1, 0, _Args...>::value == -1, "type can only occur once in type list" );
 
800
    };
 
801
 
 
802
 
 
803
template <typename _T1, size_t _Idx>
 
804
struct __find_exactly_one_t_helper <_T1, _Idx> {
 
805
    static constexpr size_t value = -1;
 
806
    };
 
807
 
 
808
template <typename _T1, size_t _Idx, typename _Head, typename... _Args>
 
809
struct __find_exactly_one_t_helper <_T1, _Idx, _Head, _Args...> {
 
810
    static constexpr size_t value =
 
811
        std::conditional<
 
812
            std::is_same<_T1, _Head>::value,
 
813
            __find_exactly_one_t_checker<_T1, _Idx,   _Args...>,
 
814
            __find_exactly_one_t_helper <_T1, _Idx+1, _Args...>
 
815
        >::type::value;
 
816
    };
 
817
 
 
818
template <typename _T1, typename... _Args>
 
819
struct __find_exactly_one_t {
 
820
    static constexpr size_t value = __find_exactly_one_t_helper<_T1, 0, _Args...>::value;
 
821
    static_assert ( value != -1, "type not found in type list" );
 
822
    };
 
823
 
 
824
template <class _T1, class... _Args>
 
825
inline _LIBCPP_INLINE_VISIBILITY
 
826
constexpr _T1& get(tuple<_Args...>& __tup) noexcept
 
827
{
 
828
    return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
 
829
}
 
830
 
 
831
template <class _T1, class... _Args>
 
832
inline _LIBCPP_INLINE_VISIBILITY
 
833
constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept
 
834
{
 
835
    return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
 
836
}
 
837
 
 
838
template <class _T1, class... _Args>
 
839
inline _LIBCPP_INLINE_VISIBILITY
 
840
constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept
 
841
{
 
842
    return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
 
843
}
 
844
 
 
845
#endif
 
846
 
786
847
// tie
787
848
 
788
849
template <class ..._Tp>
824
885
};
825
886
 
826
887
template <class... _Tp>
827
 
inline _LIBCPP_INLINE_VISIBILITY
 
888
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
828
889
tuple<typename __make_tuple_return<_Tp>::type...>
829
890
make_tuple(_Tp&&... __t)
830
891
{
832
893
}
833
894
 
834
895
template <class... _Tp>
 
896
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 
897
tuple<_Tp&&...>
 
898
__forward_as_tuple(_Tp&&... __t) _NOEXCEPT
 
899
{
 
900
    return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
 
901
}
 
902
 
 
903
template <class... _Tp>
835
904
inline _LIBCPP_INLINE_VISIBILITY
836
905
tuple<_Tp&&...>
837
906
forward_as_tuple(_Tp&&... __t) _NOEXCEPT
843
912
struct __tuple_equal
844
913
{
845
914
    template <class _Tp, class _Up>
846
 
    _LIBCPP_INLINE_VISIBILITY
 
915
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
847
916
    bool operator()(const _Tp& __x, const _Up& __y)
848
917
    {
849
918
        return __tuple_equal<_Ip - 1>()(__x, __y) && get<_Ip-1>(__x) == get<_Ip-1>(__y);
854
923
struct __tuple_equal<0>
855
924
{
856
925
    template <class _Tp, class _Up>
857
 
    _LIBCPP_INLINE_VISIBILITY
 
926
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
858
927
    bool operator()(const _Tp&, const _Up&)
859
928
    {
860
929
        return true;
862
931
};
863
932
 
864
933
template <class ..._Tp, class ..._Up>
865
 
inline _LIBCPP_INLINE_VISIBILITY
 
934
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
866
935
bool
867
936
operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
868
937
{
870
939
}
871
940
 
872
941
template <class ..._Tp, class ..._Up>
873
 
inline _LIBCPP_INLINE_VISIBILITY
 
942
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
874
943
bool
875
944
operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
876
945
{
881
950
struct __tuple_less
882
951
{
883
952
    template <class _Tp, class _Up>
884
 
    _LIBCPP_INLINE_VISIBILITY
 
953
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
885
954
    bool operator()(const _Tp& __x, const _Up& __y)
886
955
    {
887
956
        return __tuple_less<_Ip-1>()(__x, __y) ||
893
962
struct __tuple_less<0>
894
963
{
895
964
    template <class _Tp, class _Up>
896
 
    _LIBCPP_INLINE_VISIBILITY
 
965
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
897
966
    bool operator()(const _Tp&, const _Up&)
898
967
    {
899
968
        return false;
901
970
};
902
971
 
903
972
template <class ..._Tp, class ..._Up>
904
 
inline _LIBCPP_INLINE_VISIBILITY
 
973
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
905
974
bool
906
975
operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
907
976
{
909
978
}
910
979
 
911
980
template <class ..._Tp, class ..._Up>
912
 
inline _LIBCPP_INLINE_VISIBILITY
 
981
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
913
982
bool
914
983
operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
915
984
{
917
986
}
918
987
 
919
988
template <class ..._Tp, class ..._Up>
920
 
inline _LIBCPP_INLINE_VISIBILITY
 
989
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
921
990
bool
922
991
operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
923
992
{
925
994
}
926
995
 
927
996
template <class ..._Tp, class ..._Up>
928
 
inline _LIBCPP_INLINE_VISIBILITY
 
997
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
929
998
bool
930
999
operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
931
1000
{
983
1052
    typedef tuple<> type;
984
1053
};
985
1054
 
986
 
inline _LIBCPP_INLINE_VISIBILITY
 
1055
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
987
1056
tuple<>
988
1057
tuple_cat()
989
1058
{
1030
1099
struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
1031
1100
{
1032
1101
    template <class _Tuple0>
1033
 
    _LIBCPP_INLINE_VISIBILITY
 
1102
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1034
1103
    typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
1035
1104
    operator()(tuple<_Types...> __t, _Tuple0&& __t0)
1036
1105
    {
1037
 
        return _VSTD::forward_as_tuple(_VSTD::forward<_Types>(get<_I0>(__t))...,
 
1106
        return __forward_as_tuple(_VSTD::forward<_Types>(get<_I0>(__t))...,
1038
1107
                                      get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
1039
1108
    }
1040
1109
 
1041
1110
    template <class _Tuple0, class _Tuple1, class ..._Tuples>
1042
 
    _LIBCPP_INLINE_VISIBILITY
 
1111
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1043
1112
    typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
1044
1113
    operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
1045
1114
    {
1049
1118
           tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
1050
1119
           typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
1051
1120
           typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
1052
 
                           (_VSTD::forward_as_tuple(
 
1121
                           (__forward_as_tuple(
1053
1122
                              _VSTD::forward<_Types>(get<_I0>(__t))...,
1054
1123
                              get<_J0>(_VSTD::forward<_Tuple0>(__t0))...
1055
1124
                            ),
1059
1128
};
1060
1129
 
1061
1130
template <class _Tuple0, class... _Tuples>
1062
 
inline _LIBCPP_INLINE_VISIBILITY
 
1131
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1063
1132
typename __tuple_cat_return<_Tuple0, _Tuples...>::type
1064
1133
tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
1065
1134
{