← Back to branch summary

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

« back to all changes in this revision

Viewing changes to system/include/libcxx/type_traits

  • 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/type_traits
129
129
    template <class T> struct alignment_of;
130
130
    template <size_t Len, size_t Align = most_stringent_alignment_requirement>
131
131
        struct aligned_storage;
 
132
    template <size_t Len, class... Types> struct aligned_union;
132
133
 
133
134
    template <class T> struct decay;
134
135
    template <class... T> struct common_type;
136
137
    template <class> class result_of; // undefined
137
138
    template <class Fn, class... ArgTypes> class result_of<Fn(ArgTypes...)>;
138
139
 
 
140
    // const-volatile modifications:
 
141
    template <class T>
 
142
      using remove_const_t    = typename remove_const<T>::type;  // C++14
 
143
    template <class T>
 
144
      using remove_volatile_t = typename remove_volatile<T>::type;  // C++14
 
145
    template <class T>
 
146
      using remove_cv_t       = typename remove_cv<T>::type;  // C++14
 
147
    template <class T>
 
148
      using add_const_t       = typename add_const<T>::type;  // C++14
 
149
    template <class T>
 
150
      using add_volatile_t    = typename add_volatile<T>::type;  // C++14
 
151
    template <class T>
 
152
      using add_cv_t          = typename add_cv<T>::type;  // C++14
 
153
  
 
154
    // reference modifications:
 
155
    template <class T>
 
156
      using remove_reference_t     = typename remove_reference<T>::type;  // C++14
 
157
    template <class T>
 
158
      using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;  // C++14
 
159
    template <class T>
 
160
      using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;  // C++14
 
161
  
 
162
    // sign modifications:
 
163
    template <class T>
 
164
      using make_signed_t   = typename make_signed<T>::type;  // C++14
 
165
    template <class T>
 
166
      using make_unsigned_t = typename make_unsigned<T>::type;  // C++14
 
167
  
 
168
    // array modifications:
 
169
    template <class T>
 
170
      using remove_extent_t      = typename remove_extent<T>::type;  // C++14
 
171
    template <class T>
 
172
      using remove_all_extents_t = typename remove_all_extents<T>::type;  // C++14
 
173
 
 
174
    // pointer modifications:
 
175
    template <class T>
 
176
      using remove_pointer_t = typename remove_pointer<T>::type;  // C++14
 
177
    template <class T>
 
178
      using add_pointer_t    = typename add_pointer<T>::type;  // C++14
 
179
 
 
180
    // other transformations:
 
181
    template <size_t Len, std::size_t Align=default-alignment>
 
182
      using aligned_storage_t = typename aligned_storage<Len,Align>::type;  // C++14
 
183
    template <std::size_t Len, class... Types>
 
184
      using aligned_union_t   = typename aligned_union<Len,Types...>::type;  // C++14
 
185
    template <class T>
 
186
      using decay_t           = typename decay<T>::type;  // C++14
 
187
    template <bool b, class T=void>
 
188
      using enable_if_t       = typename enable_if<b,T>::type;  // C++14
 
189
    template <bool b, class T, class F>
 
190
      using conditional_t     = typename conditional<b,T,F>::type;  // C++14
 
191
    template <class... T>
 
192
      using common_type_t     = typename common_type<T...>::type;  // C++14
 
193
    template <class T>
 
194
      using underlying_type_t = typename underlying_type<T>::type;  // C++14
 
195
    template <class F, class... ArgTypes>
 
196
      using result_of_t       = typename result_of<F(ArgTypes...)>::type;  // C++14
 
197
 
139
198
}  // std
140
199
 
141
200
*/
153
212
template <class _If, class _Then>
154
213
    struct _LIBCPP_TYPE_VIS conditional<false, _If, _Then> {typedef _Then type;};
155
214
 
 
215
#if _LIBCPP_STD_VER > 11
 
216
template <bool _Bp, class _If, class _Then> using conditional_t = typename conditional<_Bp, _If, _Then>::type;
 
217
#endif
 
218
 
156
219
template <bool, class _Tp = void> struct _LIBCPP_TYPE_VIS enable_if {};
157
220
template <class _Tp> struct _LIBCPP_TYPE_VIS enable_if<true, _Tp> {typedef _Tp type;};
158
221
 
 
222
#if _LIBCPP_STD_VER > 11
 
223
template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type;
 
224
#endif
 
225
 
 
226
 
159
227
struct __two {char __lx[2];};
160
228
 
161
229
// helper class:
168
236
    typedef integral_constant type;
169
237
    _LIBCPP_INLINE_VISIBILITY
170
238
        _LIBCPP_CONSTEXPR operator value_type() const {return value;}
 
239
#if _LIBCPP_STD_VER > 11
 
240
    _LIBCPP_INLINE_VISIBILITY
 
241
         constexpr value_type operator ()() const {return value;}
 
242
#endif
171
243
};
172
244
 
173
245
template <class _Tp, _Tp __v>
190
262
 
191
263
template <class _Tp> struct _LIBCPP_TYPE_VIS remove_const            {typedef _Tp type;};
192
264
template <class _Tp> struct _LIBCPP_TYPE_VIS remove_const<const _Tp> {typedef _Tp type;};
 
265
#if _LIBCPP_STD_VER > 11
 
266
template <class _Tp> using remove_const_t = typename remove_const<_Tp>::type;
 
267
#endif
193
268
 
194
269
// remove_volatile
195
270
 
196
271
template <class _Tp> struct _LIBCPP_TYPE_VIS remove_volatile               {typedef _Tp type;};
197
272
template <class _Tp> struct _LIBCPP_TYPE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;};
 
273
#if _LIBCPP_STD_VER > 11
 
274
template <class _Tp> using remove_volatile_t = typename remove_volatile<_Tp>::type;
 
275
#endif
198
276
 
199
277
// remove_cv
200
278
 
201
279
template <class _Tp> struct _LIBCPP_TYPE_VIS remove_cv
202
280
{typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;};
 
281
#if _LIBCPP_STD_VER > 11
 
282
template <class _Tp> using remove_cv_t = typename remove_cv<_Tp>::type;
 
283
#endif
203
284
 
204
285
// is_void
205
286
 
445
526
template <class _Tp> struct _LIBCPP_TYPE_VIS add_const
446
527
    {typedef typename __add_const<_Tp>::type type;};
447
528
 
 
529
#if _LIBCPP_STD_VER > 11
 
530
template <class _Tp> using add_const_t = typename add_const<_Tp>::type;
 
531
#endif
 
532
 
448
533
// add_volatile
449
534
 
450
535
template <class _Tp, bool = is_reference<_Tp>::value ||
458
543
template <class _Tp> struct _LIBCPP_TYPE_VIS add_volatile
459
544
    {typedef typename __add_volatile<_Tp>::type type;};
460
545
 
 
546
#if _LIBCPP_STD_VER > 11
 
547
template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type;
 
548
#endif
 
549
 
461
550
// add_cv
462
551
 
463
552
template <class _Tp> struct _LIBCPP_TYPE_VIS add_cv
464
553
    {typedef typename add_const<typename add_volatile<_Tp>::type>::type type;};
465
554
 
 
555
#if _LIBCPP_STD_VER > 11
 
556
template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type;
 
557
#endif
 
558
 
466
559
// remove_reference
467
560
 
468
561
template <class _Tp> struct _LIBCPP_TYPE_VIS remove_reference        {typedef _Tp type;};
471
564
template <class _Tp> struct _LIBCPP_TYPE_VIS remove_reference<_Tp&&> {typedef _Tp type;};
472
565
#endif
473
566
 
 
567
#if _LIBCPP_STD_VER > 11
 
568
template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::type;
 
569
#endif
 
570
 
474
571
// add_lvalue_reference
475
572
 
476
573
template <class _Tp> struct _LIBCPP_TYPE_VIS add_lvalue_reference                      {typedef _Tp& type;};
480
577
template <>          struct _LIBCPP_TYPE_VIS add_lvalue_reference<volatile void>       {typedef volatile void type;};
481
578
template <>          struct _LIBCPP_TYPE_VIS add_lvalue_reference<const volatile void> {typedef const volatile void type;};
482
579
 
 
580
#if _LIBCPP_STD_VER > 11
 
581
template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
 
582
#endif
 
583
 
483
584
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
484
585
 
485
586
template <class _Tp> struct _LIBCPP_TYPE_VIS  add_rvalue_reference                     {typedef _Tp&& type;};
488
589
template <>          struct _LIBCPP_TYPE_VIS add_rvalue_reference<volatile void>       {typedef volatile void type;};
489
590
template <>          struct _LIBCPP_TYPE_VIS add_rvalue_reference<const volatile void> {typedef const volatile void type;};
490
591
 
 
592
#if _LIBCPP_STD_VER > 11
 
593
template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
 
594
#endif
 
595
 
491
596
#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
492
597
 
493
598
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
517
622
template <class _Tp> struct _LIBCPP_TYPE_VIS remove_pointer<_Tp* volatile>       {typedef _Tp type;};
518
623
template <class _Tp> struct _LIBCPP_TYPE_VIS remove_pointer<_Tp* const volatile> {typedef _Tp type;};
519
624
 
 
625
#if _LIBCPP_STD_VER > 11
 
626
template <class _Tp> using remove_pointer_t = typename remove_pointer<_Tp>::type;
 
627
#endif
 
628
 
520
629
// add_pointer
521
630
 
522
631
template <class _Tp> struct _LIBCPP_TYPE_VIS add_pointer
523
632
    {typedef typename remove_reference<_Tp>::type* type;};
524
633
 
 
634
#if _LIBCPP_STD_VER > 11
 
635
template <class _Tp> using add_pointer_t = typename add_pointer<_Tp>::type;
 
636
#endif
 
637
 
525
638
// is_signed
526
639
 
527
640
template <class _Tp, bool = is_integral<_Tp>::value>
583
696
template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS remove_extent<_Tp[_Np]>
584
697
    {typedef _Tp type;};
585
698
 
 
699
#if _LIBCPP_STD_VER > 11
 
700
template <class _Tp> using remove_extent_t = typename remove_extent<_Tp>::type;
 
701
#endif
 
702
 
586
703
// remove_all_extents
587
704
 
588
705
template <class _Tp> struct _LIBCPP_TYPE_VIS remove_all_extents
592
709
template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS remove_all_extents<_Tp[_Np]>
593
710
    {typedef typename remove_all_extents<_Tp>::type type;};
594
711
 
 
712
#if _LIBCPP_STD_VER > 11
 
713
template <class _Tp> using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
 
714
#endif
 
715
 
595
716
// is_abstract
596
717
 
597
718
namespace __is_abstract_imp
609
730
 
610
731
// is_base_of
611
732
 
612
 
#ifdef _LIBCP_HAS_IS_BASE_OF
 
733
#ifdef _LIBCPP_HAS_IS_BASE_OF
613
734
 
614
735
template <class _Bp, class _Dp>
615
736
struct _LIBCPP_TYPE_VIS is_base_of
802
923
 
803
924
#else
804
925
 
805
 
template <class _Tp> struct __is_polymorphic1 : public _Tp {};
806
 
template <class _Tp> struct __is_polymorphic2 : public _Tp {virtual ~__is_polymorphic2() throw();};
807
 
 
808
 
template <class _Tp, bool = is_class<_Tp>::value>
809
 
struct __libcpp_polymorphic
810
 
    : public integral_constant<bool, sizeof(__is_polymorphic1<_Tp>) == sizeof(__is_polymorphic2<_Tp>)> {};
811
 
 
812
 
template <class _Tp> struct __libcpp_polymorphic<_Tp, false> : public false_type {};
 
926
template<typename _Tp> char &__is_polymorphic_impl(
 
927
    typename enable_if<sizeof((_Tp*)dynamic_cast<const volatile void*>(declval<_Tp*>())) != 0,
 
928
                       int>::type);
 
929
template<typename _Tp> __two &__is_polymorphic_impl(...);
813
930
 
814
931
template <class _Tp> struct _LIBCPP_TYPE_VIS is_polymorphic
815
 
    : public __libcpp_polymorphic<_Tp> {};
 
932
    : public integral_constant<bool, sizeof(__is_polymorphic_impl<_Tp>(0)) == 1> {};
816
933
 
817
934
#endif // __has_feature(is_polymorphic)
818
935
 
832
949
 
833
950
// alignment_of
834
951
 
835
 
template <class _Tp> struct __alignment_of {_Tp __lx;};
836
 
 
837
952
template <class _Tp> struct _LIBCPP_TYPE_VIS alignment_of
838
 
    : public integral_constant<size_t, __alignof__(__alignment_of<typename remove_all_extents<_Tp>::type>)> {};
 
953
    : public integral_constant<size_t, __alignof__(_Tp)> {};
839
954
 
840
955
// aligned_storage
841
956
 
921
1036
struct __find_max_align<__type_list<_Hp, _Tp>, _Len>
922
1037
    : public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {};
923
1038
 
924
 
template <size_t _Len, const size_t _Align = __find_max_align<__all_types, _Len>::value>
 
1039
template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
925
1040
struct _LIBCPP_TYPE_VIS aligned_storage
926
1041
{
927
1042
    typedef typename __find_pod<__all_types, _Align>::type _Aligner;
933
1048
    };
934
1049
};
935
1050
 
 
1051
#if _LIBCPP_STD_VER > 11
 
1052
template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
 
1053
    using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
 
1054
#endif
 
1055
 
936
1056
#define _CREATE_ALIGNED_STORAGE_SPECIALIZATION(n) \
937
1057
template <size_t _Len>\
938
1058
struct _LIBCPP_TYPE_VIS aligned_storage<_Len, n>\
958
1078
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1000);
959
1079
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2000);
960
1080
// MSDN says that MSVC does not support alignment beyond 8192 (=0x2000)
961
 
#if !defined(_MSC_VER)
 
1081
#if !defined(_LIBCPP_MSVC)
962
1082
_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4000);
963
 
#endif // !_MSC_VER
 
1083
#endif // !_LIBCPP_MSVC
964
1084
 
965
1085
#undef _CREATE_ALIGNED_STORAGE_SPECIALIZATION
966
1086
 
 
1087
#ifndef _LIBCPP_HAS_NO_VARIADICS
 
1088
 
 
1089
// aligned_union
 
1090
 
 
1091
template <size_t _I0, size_t ..._In>
 
1092
struct __static_max;
 
1093
 
 
1094
template <size_t _I0>
 
1095
struct __static_max<_I0>
 
1096
{
 
1097
    static const size_t value = _I0;
 
1098
};
 
1099
 
 
1100
template <size_t _I0, size_t _I1, size_t ..._In>
 
1101
struct __static_max<_I0, _I1, _In...>
 
1102
{
 
1103
    static const size_t value = _I0 >= _I1 ? __static_max<_I0, _In...>::value :
 
1104
                                             __static_max<_I1, _In...>::value;
 
1105
};
 
1106
 
 
1107
template <size_t _Len, class _Type0, class ..._Types>
 
1108
struct aligned_union
 
1109
{
 
1110
    static const size_t alignment_value = __static_max<__alignof__(_Type0),
 
1111
                                                       __alignof__(_Types)...>::value;
 
1112
    static const size_t __len = __static_max<_Len, sizeof(_Type0),
 
1113
                                             sizeof(_Types)...>::value;
 
1114
    typedef typename aligned_storage<__len, alignment_value>::type type;
 
1115
};
 
1116
 
 
1117
#if _LIBCPP_STD_VER > 11
 
1118
template <size_t _Len, class ..._Types> using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
 
1119
#endif
 
1120
 
 
1121
#endif  // _LIBCPP_HAS_NO_VARIADICS
 
1122
 
967
1123
// __promote
968
1124
 
969
1125
template <class _A1, class _A2 = void, class _A3 = void,
1123
1279
    typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type;
1124
1280
};
1125
1281
 
 
1282
#if _LIBCPP_STD_VER > 11
 
1283
template <class _Tp> using make_signed_t = typename make_signed<_Tp>::type;
 
1284
#endif
 
1285
 
1126
1286
template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value>
1127
1287
struct __make_unsigned {};
1128
1288
 
1148
1308
    typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
1149
1309
};
1150
1310
 
 
1311
#if _LIBCPP_STD_VER > 11
 
1312
template <class _Tp> using make_unsigned_t = typename make_unsigned<_Tp>::type;
 
1313
#endif
 
1314
 
1151
1315
#ifdef _LIBCPP_HAS_NO_VARIADICS
1152
1316
 
1153
1317
template <class _Tp, class _Up = void, class V = void>
1206
1370
    typedef typename common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type;
1207
1371
};
1208
1372
 
 
1373
#if _LIBCPP_STD_VER > 11
 
1374
template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type;
 
1375
#endif
 
1376
 
1209
1377
#endif  // _LIBCPP_HAS_NO_VARIADICS
1210
1378
 
1211
1379
// is_assignable
1298
1466
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1299
1467
 
1300
1468
template <class _Tp>
1301
 
inline _LIBCPP_INLINE_VISIBILITY
 
1469
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1302
1470
typename remove_reference<_Tp>::type&&
1303
1471
move(_Tp&& __t) _NOEXCEPT
1304
1472
{
1307
1475
}
1308
1476
 
1309
1477
template <class _Tp>
1310
 
inline _LIBCPP_INLINE_VISIBILITY
 
1478
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1311
1479
_Tp&&
1312
1480
forward(typename std::remove_reference<_Tp>::type& __t) _NOEXCEPT
1313
1481
{
1315
1483
}
1316
1484
 
1317
1485
template <class _Tp>
1318
 
inline _LIBCPP_INLINE_VISIBILITY
 
1486
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1319
1487
_Tp&&
1320
1488
forward(typename std::remove_reference<_Tp>::type&& __t) _NOEXCEPT
1321
1489
{
1384
1552
                     >::type type;
1385
1553
};
1386
1554
 
 
1555
#if _LIBCPP_STD_VER > 11
 
1556
template <class _Tp> using decay_t = typename decay<_Tp>::type;
 
1557
#endif
 
1558
 
1387
1559
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1388
1560
 
1389
1561
template <class _Tp>
1626
1798
 
1627
1799
template <class _MP>
1628
1800
struct __member_pointer_traits
1629
 
    : public __member_pointer_traits_imp<_MP,
 
1801
    : public __member_pointer_traits_imp<typename remove_cv<_MP>::type,
1630
1802
                    is_member_function_pointer<_MP>::value,
1631
1803
                    is_member_object_pointer<_MP>::value>
1632
1804
{
2851
3023
 
2852
3024
// bullets 1 and 2
2853
3025
 
2854
 
template <class _Fp, class _A0, class ..._Args>
 
3026
template <class _Fp, class _A0, class ..._Args,
 
3027
            class = typename enable_if
 
3028
            <
 
3029
                is_member_function_pointer<typename remove_reference<_Fp>::type>::value &&
 
3030
                is_base_of<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType,
 
3031
                           typename remove_reference<_A0>::type>::value
 
3032
            >::type
 
3033
         >
2855
3034
_LIBCPP_INLINE_VISIBILITY
2856
3035
auto
2857
3036
__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
2858
3037
    -> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...));
2859
3038
 
2860
 
template <class _Fp, class _A0, class ..._Args>
 
3039
template <class _Fp, class _A0, class ..._Args,
 
3040
            class = typename enable_if
 
3041
            <
 
3042
                is_member_function_pointer<typename remove_reference<_Fp>::type>::value &&
 
3043
                !is_base_of<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType,
 
3044
                           typename remove_reference<_A0>::type>::value
 
3045
            >::type
 
3046
         >
2861
3047
_LIBCPP_INLINE_VISIBILITY
2862
3048
auto
2863
3049
__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
2865
3051
 
2866
3052
// bullets 3 and 4
2867
3053
 
2868
 
template <class _Fp, class _A0>
 
3054
template <class _Fp, class _A0,
 
3055
            class = typename enable_if
 
3056
            <
 
3057
                is_member_object_pointer<typename remove_reference<_Fp>::type>::value &&
 
3058
                is_base_of<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType,
 
3059
                           typename remove_reference<_A0>::type>::value
 
3060
            >::type
 
3061
         >
2869
3062
_LIBCPP_INLINE_VISIBILITY
2870
3063
auto
2871
3064
__invoke(_Fp&& __f, _A0&& __a0)
2872
3065
    -> decltype(_VSTD::forward<_A0>(__a0).*__f);
2873
3066
 
2874
 
template <class _Fp, class _A0>
 
3067
template <class _Fp, class _A0,
 
3068
            class = typename enable_if
 
3069
            <
 
3070
                is_member_object_pointer<typename remove_reference<_Fp>::type>::value &&
 
3071
                !is_base_of<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType,
 
3072
                           typename remove_reference<_A0>::type>::value
 
3073
            >::type
 
3074
         >
2875
3075
_LIBCPP_INLINE_VISIBILITY
2876
3076
auto
2877
3077
__invoke(_Fp&& __f, _A0&& __a0)
2929
3129
{
2930
3130
};
2931
3131
 
 
3132
#if _LIBCPP_STD_VER > 11
 
3133
template <class _Tp> using result_of_t = typename result_of<_Tp>::type;
 
3134
#endif
 
3135
 
2932
3136
#endif  // _LIBCPP_HAS_NO_VARIADICS
2933
3137
 
2934
3138
template <class _Tp>
3023
3227
    typedef _LIBCXX_UNDERLYING_TYPE(_Tp) type;
3024
3228
};
3025
3229
 
 
3230
#if _LIBCPP_STD_VER > 11
 
3231
template <class _Tp> using underlying_type_t = typename underlying_type<_Tp>::type;
 
3232
#endif
 
3233
 
3026
3234
#else  // _LIBCXX_UNDERLYING_TYPE
3027
3235
 
3028
3236
template <class _Tp, bool _Support = false>