microsoft
/
STL
зеркало из https://github.com/microsoft/STL.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

is_constant_evaluated() is constantly available. (#454)

This commit is contained in:
Stephan T. Lavavej 2020-01-24 12:10:49 -08:00 коммит произвёл GitHub
Родитель 544de81c12
Коммит c5cde6ecba
Не найден ключ, соответствующий данной подписи
Идентификатор ключа GPG: 4AEE18F83AFDEB23
5 изменённых файлов: 81 добавлений и 102 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

63
stl/inc/algorithm
Просмотреть файл

@ -673,8 +673,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt partition_point(_FwdIt _First, _FwdIt _Last, _Pr
// FUNCTION TEMPLATE _Equal_rev_pred_unchecked // FUNCTION TEMPLATE _Equal_rev_pred_unchecked
#if _HAS_IF_CONSTEXPR #if _HAS_IF_CONSTEXPR
template <class _InIt1, class _InIt2, class _Pr> template <class _InIt1, class _InIt2, class _Pr>
_NODISCARD _CONSTEXPR20_ICE bool _Equal_rev_pred_unchecked( _NODISCARD _CONSTEXPR20 bool _Equal_rev_pred_unchecked(_InIt1 _First1, _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
_InIt1 _First1, _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
// compare [_First1, ...) to [_First2, _Last2) using _Pred // compare [_First1, ...) to [_First2, _Last2) using _Pred
if constexpr (decltype(_Equal_memcmp_is_safe(_First1, _First2, _Pred))::value) { if constexpr (decltype(_Equal_memcmp_is_safe(_First1, _First2, _Pred))::value) {
#ifdef __cpp_lib_is_constant_evaluated #ifdef __cpp_lib_is_constant_evaluated
@ -728,8 +727,8 @@ bool _Equal_rev_pred_unchecked(const _InIt1 _First1, const _InIt2 _First2, const
// FUNCTION TEMPLATE search // FUNCTION TEMPLATE search
#if _HAS_IF_CONSTEXPR #if _HAS_IF_CONSTEXPR
template <class _FwdItHaystack, class _FwdItPat, class _Pr> template <class _FwdItHaystack, class _FwdItPat, class _Pr>
_NODISCARD _CONSTEXPR20_ICE _FwdItHaystack search(_FwdItHaystack _First1, _FwdItHaystack _Last1, _NODISCARD _CONSTEXPR20 _FwdItHaystack search(_FwdItHaystack _First1, _FwdItHaystack _Last1, const _FwdItPat _First2,
const _FwdItPat _First2, const _FwdItPat _Last2, _Pr _Pred) { // find first [_First2, _Last2) satisfying _Pred const _FwdItPat _Last2, _Pr _Pred) { // find first [_First2, _Last2) satisfying _Pred
_Adl_verify_range(_First1, _Last1); _Adl_verify_range(_First1, _Last1);
_Adl_verify_range(_First2, _Last2); _Adl_verify_range(_First2, _Last2);
auto _UFirst1 = _Get_unwrapped(_First1); auto _UFirst1 = _Get_unwrapped(_First1);
@ -828,7 +827,7 @@ _NODISCARD _FwdItHaystack search(_ExPo&& _Exec, const _FwdItHaystack _First1, _F
#endif // _HAS_CXX17 #endif // _HAS_CXX17
template <class _FwdItHaystack, class _FwdItPat> template <class _FwdItHaystack, class _FwdItPat>
_NODISCARD _CONSTEXPR20_ICE _FwdItHaystack search( _NODISCARD _CONSTEXPR20 _FwdItHaystack search(
const _FwdItHaystack _First1, const _FwdItHaystack _Last1, const _FwdItPat _First2, const _FwdItPat _Last2) { const _FwdItHaystack _First1, const _FwdItHaystack _Last1, const _FwdItPat _First2, const _FwdItPat _Last2) {
// find first [_First2, _Last2) match // find first [_First2, _Last2) match
return _STD search(_First1, _Last1, _First2, _Last2, equal_to<>()); return _STD search(_First1, _Last1, _First2, _Last2, equal_to<>());
@ -1274,7 +1273,7 @@ _CONSTEXPR20 _FwdIt2 _Swap_ranges_unchecked(_FwdIt1 _First1, const _FwdIt1 _Last
#if (defined(_M_IX86) || defined(_M_X64)) && !defined(_M_CEE_PURE) && !defined(_M_HYBRID) #if (defined(_M_IX86) || defined(_M_X64)) && !defined(_M_CEE_PURE) && !defined(_M_HYBRID)
template <class _Ty, enable_if_t<_Is_trivially_swappable_v<_Ty>, int> = 0> template <class _Ty, enable_if_t<_Is_trivially_swappable_v<_Ty>, int> = 0>
_CONSTEXPR20_ICE _Ty* _Swap_ranges_unchecked(_Ty* _First1, _Ty* const _Last1, _Ty* _First2) { _CONSTEXPR20 _Ty* _Swap_ranges_unchecked(_Ty* _First1, _Ty* const _Last1, _Ty* _First2) {
// swap [_First1, _Last1) with [_First2, ...), trivially swappable optimization // swap [_First1, _Last1) with [_First2, ...), trivially swappable optimization
#ifdef __cpp_lib_is_constant_evaluated #ifdef __cpp_lib_is_constant_evaluated
if (!_STD is_constant_evaluated()) if (!_STD is_constant_evaluated())
@ -1293,7 +1292,7 @@ _CONSTEXPR20_ICE _Ty* _Swap_ranges_unchecked(_Ty* _First1, _Ty* const _Last1, _T
#endif // (defined(_M_IX86) || defined(_M_X64)) && !defined(_M_CEE_PURE) && !defined(_M_HYBRID) #endif // (defined(_M_IX86) || defined(_M_X64)) && !defined(_M_CEE_PURE) && !defined(_M_HYBRID)
template <class _FwdIt1, class _FwdIt2> template <class _FwdIt1, class _FwdIt2>
_CONSTEXPR20_ICE _FwdIt2 swap_ranges(const _FwdIt1 _First1, const _FwdIt1 _Last1, _FwdIt2 _First2) { _CONSTEXPR20 _FwdIt2 swap_ranges(const _FwdIt1 _First1, const _FwdIt1 _Last1, _FwdIt2 _First2) {
// swap [_First1, _Last1) with [_First2, ...) // swap [_First1, _Last1) with [_First2, ...)
_Adl_verify_range(_First1, _Last1); _Adl_verify_range(_First1, _Last1);
const auto _UFirst1 = _Get_unwrapped(_First1); const auto _UFirst1 = _Get_unwrapped(_First1);
@ -1305,7 +1304,7 @@ _CONSTEXPR20_ICE _FwdIt2 swap_ranges(const _FwdIt1 _First1, const _FwdIt1 _Last1
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _FwdIt1, class _DestTy, size_t _DestSize> template <class _FwdIt1, class _DestTy, size_t _DestSize>
_CONSTEXPR20_ICE _DestTy* swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1, _DestTy (&_Dest)[_DestSize]) { _CONSTEXPR20 _DestTy* swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1, _DestTy (&_Dest)[_DestSize]) {
// swap [_First1, _Last1) with [_Dest, ...), array dest // swap [_First1, _Last1) with [_Dest, ...), array dest
return _STD swap_ranges(_First1, _Last1, _Array_iterator<_DestTy, _DestSize>(_Dest))._Unwrapped(); return _STD swap_ranges(_First1, _Last1, _Array_iterator<_DestTy, _DestSize>(_Dest))._Unwrapped();
} }
@ -2084,7 +2083,7 @@ _DestTy* reverse_copy(_ExPo&&, _BidIt _First, _BidIt _Last, _DestTy (&_Dest)[_De
// FUNCTION TEMPLATE rotate_copy // FUNCTION TEMPLATE rotate_copy
template <class _FwdIt, class _OutIt> template <class _FwdIt, class _OutIt>
_CONSTEXPR20_ICE _OutIt rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest) { _CONSTEXPR20 _OutIt rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest) {
// copy rotating [_First, _Last) // copy rotating [_First, _Last)
_Adl_verify_range(_First, _Mid); _Adl_verify_range(_First, _Mid);
_Adl_verify_range(_Mid, _Last); _Adl_verify_range(_Mid, _Last);
@ -3014,7 +3013,7 @@ _NODISCARD constexpr auto _Idl_dist_add(_Diff1 _Lhs, _Diff2 _Rhs) {
} }
template <class _InIt1, class _InIt2, class _OutIt, class _Pr> template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
_CONSTEXPR20_ICE _OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) { _CONSTEXPR20 _OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
// copy merging ranges, both using _Pred // copy merging ranges, both using _Pred
_Adl_verify_range(_First1, _Last1); _Adl_verify_range(_First1, _Last1);
_Adl_verify_range(_First2, _Last2); _Adl_verify_range(_First2, _Last2);
@ -3056,7 +3055,7 @@ _CONSTEXPR20_ICE _OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _In
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize, class _Pr> template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize, class _Pr>
_CONSTEXPR20_ICE _DestTy* merge( _CONSTEXPR20 _DestTy* merge(
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize], _Pr _Pred) { _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize], _Pr _Pred) {
// copy merging ranges, both using _Pred, array dest // copy merging ranges, both using _Pred, array dest
return _STD merge(_First1, _Last1, _First2, _Last2, _Array_iterator<_DestTy, _DestSize>(_Dest), _Pass_fn(_Pred)) return _STD merge(_First1, _Last1, _First2, _Last2, _Array_iterator<_DestTy, _DestSize>(_Dest), _Pass_fn(_Pred))
@ -3065,15 +3064,14 @@ _CONSTEXPR20_ICE _DestTy* merge(
#endif // _ITERATOR_DEBUG_ARRAY_OVERLOADS #endif // _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _InIt2, class _OutIt> template <class _InIt1, class _InIt2, class _OutIt>
_CONSTEXPR20_ICE _OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) { _CONSTEXPR20 _OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
// copy merging ranges, both using operator< // copy merging ranges, both using operator<
return _STD merge(_First1, _Last1, _First2, _Last2, _Dest, less<>()); return _STD merge(_First1, _Last1, _First2, _Last2, _Dest, less<>());
} }
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize> template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize>
_CONSTEXPR20_ICE _DestTy* merge( _CONSTEXPR20 _DestTy* merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize]) {
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize]) {
// copy merging ranges, both using operator<, array dest // copy merging ranges, both using operator<, array dest
return _STD merge(_First1, _Last1, _First2, _Last2, _Dest, less<>()); return _STD merge(_First1, _Last1, _First2, _Last2, _Dest, less<>());
} }
@ -3394,7 +3392,7 @@ void inplace_merge(_ExPo&&, _BidIt _First, _BidIt _Mid, _BidIt _Last) noexcept /
// FUNCTION TEMPLATE sort // FUNCTION TEMPLATE sort
template <class _BidIt, class _Pr> template <class _BidIt, class _Pr>
_CONSTEXPR20_ICE _BidIt _Insertion_sort_unchecked(_BidIt _First, const _BidIt _Last, _Pr _Pred) { _CONSTEXPR20 _BidIt _Insertion_sort_unchecked(_BidIt _First, const _BidIt _Last, _Pr _Pred) {
// insertion sort [_First, _Last), using _Pred // insertion sort [_First, _Last), using _Pred
if (_First != _Last) { if (_First != _Last) {
for (_BidIt _Next = _First; ++_Next != _Last;) { // order next element for (_BidIt _Next = _First; ++_Next != _Last;) { // order next element
@ -3518,7 +3516,7 @@ _CONSTEXPR20 pair<_RanIt, _RanIt> _Partition_by_median_guess_unchecked(_RanIt _F
} }
template <class _RanIt, class _Pr> template <class _RanIt, class _Pr>
_CONSTEXPR20_ICE void _Sort_unchecked(_RanIt _First, _RanIt _Last, _Iter_diff_t<_RanIt> _Ideal, _Pr _Pred) { _CONSTEXPR20 void _Sort_unchecked(_RanIt _First, _RanIt _Last, _Iter_diff_t<_RanIt> _Ideal, _Pr _Pred) {
// order [_First, _Last), using _Pred // order [_First, _Last), using _Pred
_Iter_diff_t<_RanIt> _Count = 0; _Iter_diff_t<_RanIt> _Count = 0;
while (_ISORT_MAX < (_Count = _Last - _First) && 0 < _Ideal) { // divide and conquer by quicksort while (_ISORT_MAX < (_Count = _Last - _First) && 0 < _Ideal) { // divide and conquer by quicksort
@ -3544,7 +3542,7 @@ _CONSTEXPR20_ICE void _Sort_unchecked(_RanIt _First, _RanIt _Last, _Iter_diff_t<
} }
template <class _RanIt, class _Pr> template <class _RanIt, class _Pr>
_CONSTEXPR20_ICE void sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred) { // order [_First, _Last), using _Pred _CONSTEXPR20 void sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred) { // order [_First, _Last), using _Pred
_Adl_verify_range(_First, _Last); _Adl_verify_range(_First, _Last);
const auto _UFirst = _Get_unwrapped(_First); const auto _UFirst = _Get_unwrapped(_First);
const auto _ULast = _Get_unwrapped(_Last); const auto _ULast = _Get_unwrapped(_Last);
@ -3552,7 +3550,7 @@ _CONSTEXPR20_ICE void sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred) {
} }
template <class _RanIt> template <class _RanIt>
_CONSTEXPR20_ICE void sort(const _RanIt _First, const _RanIt _Last) { // order [_First, _Last), using operator< _CONSTEXPR20 void sort(const _RanIt _First, const _RanIt _Last) { // order [_First, _Last), using operator<
_STD sort(_First, _Last, less<>()); _STD sort(_First, _Last, less<>());
} }
@ -3873,7 +3871,7 @@ _RanIt partial_sort_copy(
// FUNCTION TEMPLATE nth_element // FUNCTION TEMPLATE nth_element
template <class _RanIt, class _Pr> template <class _RanIt, class _Pr>
_CONSTEXPR20_ICE void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred) { _CONSTEXPR20 void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred) {
// order Nth element, using _Pred // order Nth element, using _Pred
_Adl_verify_range(_First, _Nth); _Adl_verify_range(_First, _Nth);
_Adl_verify_range(_Nth, _Last); _Adl_verify_range(_Nth, _Last);
@ -3900,7 +3898,7 @@ _CONSTEXPR20_ICE void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr
} }
template <class _RanIt> template <class _RanIt>
_CONSTEXPR20_ICE void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last) { // order Nth element, using operator< _CONSTEXPR20 void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last) { // order Nth element, using operator<
_STD nth_element(_First, _Nth, _Last, less<>()); _STD nth_element(_First, _Nth, _Last, less<>());
} }
@ -3976,8 +3974,7 @@ _NODISCARD bool includes(
// FUNCTION TEMPLATE set_union // FUNCTION TEMPLATE set_union
template <class _InIt1, class _InIt2, class _OutIt, class _Pr> template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
_CONSTEXPR20_ICE _OutIt set_union( _CONSTEXPR20 _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
// OR sets [_First1, _Last1) and [_First2, _Last2), using _Pred // OR sets [_First1, _Last1) and [_First2, _Last2), using _Pred
_Adl_verify_range(_First1, _Last1); _Adl_verify_range(_First1, _Last1);
_Adl_verify_range(_First2, _Last2); _Adl_verify_range(_First2, _Last2);
@ -4009,7 +4006,7 @@ _CONSTEXPR20_ICE _OutIt set_union(
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize, class _Pr> template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize, class _Pr>
_CONSTEXPR20_ICE _DestTy* set_union( _CONSTEXPR20 _DestTy* set_union(
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize], _Pr _Pred) { _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize], _Pr _Pred) {
// OR sets [_First1, _Last1) and [_First2, _Last2), array dest // OR sets [_First1, _Last1) and [_First2, _Last2), array dest
return _STD set_union(_First1, _Last1, _First2, _Last2, _Array_iterator<_DestTy, _DestSize>(_Dest), _Pass_fn(_Pred)) return _STD set_union(_First1, _Last1, _First2, _Last2, _Array_iterator<_DestTy, _DestSize>(_Dest), _Pass_fn(_Pred))
@ -4018,14 +4015,14 @@ _CONSTEXPR20_ICE _DestTy* set_union(
#endif // _ITERATOR_DEBUG_ARRAY_OVERLOADS #endif // _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _InIt2, class _OutIt> template <class _InIt1, class _InIt2, class _OutIt>
_CONSTEXPR20_ICE _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) { _CONSTEXPR20 _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
// OR sets [_First1, _Last1) and [_First2, _Last2), using operator< // OR sets [_First1, _Last1) and [_First2, _Last2), using operator<
return _STD set_union(_First1, _Last1, _First2, _Last2, _Dest, less<>()); return _STD set_union(_First1, _Last1, _First2, _Last2, _Dest, less<>());
} }
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize> template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize>
_CONSTEXPR20_ICE _DestTy* set_union( _CONSTEXPR20 _DestTy* set_union(
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize]) { _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize]) {
// OR sets [_First1, _Last1) and [_First2, _Last2), array dest // OR sets [_First1, _Last1) and [_First2, _Last2), array dest
return _STD set_union(_First1, _Last1, _First2, _Last2, _Dest, less<>()); return _STD set_union(_First1, _Last1, _First2, _Last2, _Dest, less<>());
@ -4176,7 +4173,7 @@ _DestTy* set_intersection(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt
// FUNCTION TEMPLATE set_difference // FUNCTION TEMPLATE set_difference
template <class _InIt1, class _InIt2, class _OutIt, class _Pr> template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
_CONSTEXPR20_ICE _OutIt set_difference( _CONSTEXPR20 _OutIt set_difference(
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) { _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
// take set [_First2, _Last2) from [_First1, _Last1), using _Pred // take set [_First2, _Last2) from [_First1, _Last1), using _Pred
_Adl_verify_range(_First1, _Last1); _Adl_verify_range(_First1, _Last1);
@ -4208,7 +4205,7 @@ _CONSTEXPR20_ICE _OutIt set_difference(
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize, class _Pr> template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize, class _Pr>
_CONSTEXPR20_ICE _DestTy* set_difference( _CONSTEXPR20 _DestTy* set_difference(
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize], _Pr _Pred) { _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize], _Pr _Pred) {
// take set [_First2, _Last2) from [_First1, _Last1), array dest // take set [_First2, _Last2) from [_First1, _Last1), array dest
return _STD set_difference( return _STD set_difference(
@ -4218,14 +4215,14 @@ _CONSTEXPR20_ICE _DestTy* set_difference(
#endif // _ITERATOR_DEBUG_ARRAY_OVERLOADS #endif // _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _InIt2, class _OutIt> template <class _InIt1, class _InIt2, class _OutIt>
_CONSTEXPR20_ICE _OutIt set_difference(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) { _CONSTEXPR20 _OutIt set_difference(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
// take set [_First2, _Last2) from [_First1, _Last1), using operator< // take set [_First2, _Last2) from [_First1, _Last1), using operator<
return _STD set_difference(_First1, _Last1, _First2, _Last2, _Dest, less<>()); return _STD set_difference(_First1, _Last1, _First2, _Last2, _Dest, less<>());
} }
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize> template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize>
_CONSTEXPR20_ICE _DestTy* set_difference( _CONSTEXPR20 _DestTy* set_difference(
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize]) { _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize]) {
// take set [_First2, _Last2) from [_First1, _Last1), array dest // take set [_First2, _Last2) from [_First1, _Last1), array dest
return _STD set_difference(_First1, _Last1, _First2, _Last2, _Dest, less<>()); return _STD set_difference(_First1, _Last1, _First2, _Last2, _Dest, less<>());
@ -4269,7 +4266,7 @@ _DestTy* set_difference(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2
// FUNCTION TEMPLATE set_symmetric_difference // FUNCTION TEMPLATE set_symmetric_difference
template <class _InIt1, class _InIt2, class _OutIt, class _Pr> template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
_CONSTEXPR20_ICE _OutIt set_symmetric_difference( _CONSTEXPR20 _OutIt set_symmetric_difference(
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) { _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
// XOR sets [_First1, _Last1) and [_First2, _Last2), using _Pred // XOR sets [_First1, _Last1) and [_First2, _Last2), using _Pred
_Adl_verify_range(_First1, _Last1); _Adl_verify_range(_First1, _Last1);
@ -4303,7 +4300,7 @@ _CONSTEXPR20_ICE _OutIt set_symmetric_difference(
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize, class _Pr> template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize, class _Pr>
_CONSTEXPR20_ICE _DestTy* set_symmetric_difference( _CONSTEXPR20 _DestTy* set_symmetric_difference(
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize], _Pr _Pred) { _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize], _Pr _Pred) {
// XOR sets [_First1, _Last1) and [_First2, _Last2), array dest // XOR sets [_First1, _Last1) and [_First2, _Last2), array dest
return _STD set_symmetric_difference( return _STD set_symmetric_difference(
@ -4313,7 +4310,7 @@ _CONSTEXPR20_ICE _DestTy* set_symmetric_difference(
#endif // _ITERATOR_DEBUG_ARRAY_OVERLOADS #endif // _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _InIt2, class _OutIt> template <class _InIt1, class _InIt2, class _OutIt>
_CONSTEXPR20_ICE _OutIt set_symmetric_difference( _CONSTEXPR20 _OutIt set_symmetric_difference(
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) { _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
// XOR sets [_First1, _Last1) and [_First2, _Last2), using operator< // XOR sets [_First1, _Last1) and [_First2, _Last2), using operator<
return _STD set_symmetric_difference(_First1, _Last1, _First2, _Last2, _Dest, less<>()); return _STD set_symmetric_difference(_First1, _Last1, _First2, _Last2, _Dest, less<>());
@ -4321,7 +4318,7 @@ _CONSTEXPR20_ICE _OutIt set_symmetric_difference(
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize> template <class _InIt1, class _InIt2, class _DestTy, size_t _DestSize>
_CONSTEXPR20_ICE _DestTy* set_symmetric_difference( _CONSTEXPR20 _DestTy* set_symmetric_difference(
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize]) { _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _DestTy (&_Dest)[_DestSize]) {
// XOR sets [_First1, _Last1) and [_First2, _Last2), array dest // XOR sets [_First1, _Last1) and [_First2, _Last2), array dest
return _STD set_symmetric_difference(_First1, _Last1, _First2, _Last2, _Dest, less<>()); return _STD set_symmetric_difference(_First1, _Last1, _First2, _Last2, _Dest, less<>());

19
stl/inc/numeric
Просмотреть файл

@ -70,7 +70,7 @@ inline constexpr bool _Plus_on_arithmetic_ranges_reduction_v = false;
#endif // _STD_VECTORIZE_WITH_FLOAT_CONTROL #endif // _STD_VECTORIZE_WITH_FLOAT_CONTROL
template <class _InIt, class _Ty, class _BinOp> template <class _InIt, class _Ty, class _BinOp>
_NODISCARD _CONSTEXPR20_ICE _Ty reduce(const _InIt _First, const _InIt _Last, _Ty _Val, _BinOp _Reduce_op) { _NODISCARD _CONSTEXPR20 _Ty reduce(const _InIt _First, const _InIt _Last, _Ty _Val, _BinOp _Reduce_op) {
// return commutative and associative reduction of _Val and [_First, _Last), using _Reduce_op // return commutative and associative reduction of _Val and [_First, _Last), using _Reduce_op
_Adl_verify_range(_First, _Last); _Adl_verify_range(_First, _Last);
auto _UFirst = _Get_unwrapped(_First); auto _UFirst = _Get_unwrapped(_First);
@ -78,7 +78,7 @@ _NODISCARD _CONSTEXPR20_ICE _Ty reduce(const _InIt _First, const _InIt _Last, _T
if constexpr (_Plus_on_arithmetic_ranges_reduction_v<_Unwrapped_t<const _InIt&>, _Ty, _BinOp>) { if constexpr (_Plus_on_arithmetic_ranges_reduction_v<_Unwrapped_t<const _InIt&>, _Ty, _BinOp>) {
#ifdef __cpp_lib_is_constant_evaluated #ifdef __cpp_lib_is_constant_evaluated
if (!_STD is_constant_evaluated()) if (!_STD is_constant_evaluated())
#endif #endif // __cpp_lib_is_constant_evaluated
{ {
(void) _Reduce_op; // TRANSITION, VSO-486357 (void) _Reduce_op; // TRANSITION, VSO-486357
return _Reduce_plus_arithmetic_ranges(_UFirst, _ULast, _Val); return _Reduce_plus_arithmetic_ranges(_UFirst, _ULast, _Val);
@ -93,13 +93,13 @@ _NODISCARD _CONSTEXPR20_ICE _Ty reduce(const _InIt _First, const _InIt _Last, _T
} }
template <class _InIt, class _Ty> template <class _InIt, class _Ty>
_NODISCARD _CONSTEXPR20_ICE _Ty reduce(const _InIt _First, const _InIt _Last, _Ty _Val) { _NODISCARD _CONSTEXPR20 _Ty reduce(const _InIt _First, const _InIt _Last, _Ty _Val) {
// return commutative and associative reduction of _Val and [_First, _Last) // return commutative and associative reduction of _Val and [_First, _Last)
return _STD reduce(_First, _Last, _STD move(_Val), plus<>{}); return _STD reduce(_First, _Last, _STD move(_Val), plus<>{});
} }
template <class _InIt> template <class _InIt>
_NODISCARD _CONSTEXPR20_ICE _Iter_value_t<_InIt> reduce(const _InIt _First, const _InIt _Last) { _NODISCARD _CONSTEXPR20 _Iter_value_t<_InIt> reduce(const _InIt _First, const _InIt _Last) {
// return commutative and associative reduction of // return commutative and associative reduction of
// iterator_traits<_InIt>::value_type{} and [_First, _Last) // iterator_traits<_InIt>::value_type{} and [_First, _Last)
return _STD reduce(_First, _Last, _Iter_value_t<_InIt>{}, plus<>{}); return _STD reduce(_First, _Last, _Iter_value_t<_InIt>{}, plus<>{});
@ -198,7 +198,7 @@ inline constexpr bool _Default_ops_transform_reduce_v = false;
#endif // _STD_VECTORIZE_WITH_FLOAT_CONTROL #endif // _STD_VECTORIZE_WITH_FLOAT_CONTROL
template <class _InIt1, class _InIt2, class _Ty, class _BinOp1, class _BinOp2> template <class _InIt1, class _InIt2, class _Ty, class _BinOp1, class _BinOp2>
_NODISCARD _CONSTEXPR20_ICE _Ty transform_reduce( _NODISCARD _CONSTEXPR20 _Ty transform_reduce(
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val, _BinOp1 _Reduce_op, _BinOp2 _Transform_op) { _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val, _BinOp1 _Reduce_op, _BinOp2 _Transform_op) {
// return commutative and associative transform-reduction of sequences, using // return commutative and associative transform-reduction of sequences, using
// _Reduce_op and _Transform_op // _Reduce_op and _Transform_op
@ -227,8 +227,8 @@ _NODISCARD _CONSTEXPR20_ICE _Ty transform_reduce(
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _RightTy, size_t _RightSize, class _Ty, class _BinOp1, class _BinOp2> template <class _InIt1, class _RightTy, size_t _RightSize, class _Ty, class _BinOp1, class _BinOp2>
_NODISCARD _CONSTEXPR20_ICE _Ty transform_reduce(const _InIt1 _First1, const _InIt1 _Last1, _NODISCARD _CONSTEXPR20 _Ty transform_reduce(const _InIt1 _First1, const _InIt1 _Last1, _RightTy (&_First2)[_RightSize],
_RightTy (&_First2)[_RightSize], _Ty _Val, _BinOp1 _Reduce_op, _BinOp2 _Transform_op) { _Ty _Val, _BinOp1 _Reduce_op, _BinOp2 _Transform_op) {
// return commutative and associative transform-reduction of // return commutative and associative transform-reduction of
// sequences, using _Reduce_op and _Transform_op // sequences, using _Reduce_op and _Transform_op
return _STD transform_reduce(_First1, _Last1, _Array_iterator<_RightTy, _RightSize>(_First2), _STD move(_Val), return _STD transform_reduce(_First1, _Last1, _Array_iterator<_RightTy, _RightSize>(_First2), _STD move(_Val),
@ -237,15 +237,14 @@ _NODISCARD _CONSTEXPR20_ICE _Ty transform_reduce(const _InIt1 _First1, const _In
#endif // _ITERATOR_DEBUG_ARRAY_OVERLOADS #endif // _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _InIt2, class _Ty> template <class _InIt1, class _InIt2, class _Ty>
_NODISCARD _CONSTEXPR20_ICE _Ty transform_reduce(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val) { _NODISCARD _CONSTEXPR20 _Ty transform_reduce(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val) {
// return commutative and associative transform-reduction of sequences // return commutative and associative transform-reduction of sequences
return _STD transform_reduce(_First1, _Last1, _First2, _STD move(_Val), plus<>{}, multiplies<>{}); return _STD transform_reduce(_First1, _Last1, _First2, _STD move(_Val), plus<>{}, multiplies<>{});
} }
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _RightTy, size_t _RightSize, class _Ty> template <class _InIt1, class _RightTy, size_t _RightSize, class _Ty>
_NODISCARD _CONSTEXPR20_ICE _Ty transform_reduce( _NODISCARD _CONSTEXPR20 _Ty transform_reduce(_InIt1 _First1, _InIt1 _Last1, _RightTy (&_First2)[_RightSize], _Ty _Val) {
_InIt1 _First1, _InIt1 _Last1, _RightTy (&_First2)[_RightSize], _Ty _Val) {
// return commutative and associative transform-reduction of sequences // return commutative and associative transform-reduction of sequences
return _STD transform_reduce(_First1, _Last1, _First2, _STD move(_Val), plus<>{}, multiplies<>{}); return _STD transform_reduce(_First1, _Last1, _First2, _STD move(_Val), plus<>{}, multiplies<>{});
} }

2
stl/inc/type_traits
Просмотреть файл

@ -1781,12 +1781,10 @@ inline constexpr bool is_nothrow_invocable_r_v =
#endif // _HAS_CXX17 #endif // _HAS_CXX17
#if _HAS_CXX20 #if _HAS_CXX20
#ifdef __cpp_lib_is_constant_evaluated // TRANSITION, VS 2019 16.5 Preview 2
// FUNCTION is_constant_evaluated // FUNCTION is_constant_evaluated
_NODISCARD constexpr bool is_constant_evaluated() noexcept { _NODISCARD constexpr bool is_constant_evaluated() noexcept {
return __builtin_is_constant_evaluated(); return __builtin_is_constant_evaluated();
} }
#endif // __cpp_lib_is_constant_evaluated
#endif // _HAS_CXX20 #endif // _HAS_CXX20
// STRUCT TEMPLATE _Weak_types // STRUCT TEMPLATE _Weak_types

54
stl/inc/xutility
Просмотреть файл

@ -3598,7 +3598,7 @@ _OutIt _Copy_memmove(move_iterator<_InIt> _First, move_iterator<_InIt> _Last, _O
#if _HAS_IF_CONSTEXPR #if _HAS_IF_CONSTEXPR
template <class _InIt, class _OutIt> template <class _InIt, class _OutIt>
_CONSTEXPR20_ICE _OutIt _Copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest) { _CONSTEXPR20 _OutIt _Copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest) {
// copy [_First, _Last) to [_Dest, ...) // copy [_First, _Last) to [_Dest, ...)
// note: _Copy_unchecked has callers other than the copy family // note: _Copy_unchecked has callers other than the copy family
if constexpr (_Ptr_copy_cat<_InIt, _OutIt>::_Trivially_copyable) { if constexpr (_Ptr_copy_cat<_InIt, _OutIt>::_Trivially_copyable) {
@ -3642,7 +3642,7 @@ _OutIt _Copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest) {
#endif // _HAS_IF_CONSTEXPR #endif // _HAS_IF_CONSTEXPR
template <class _InIt, class _OutIt> template <class _InIt, class _OutIt>
_CONSTEXPR20_ICE _OutIt copy(_InIt _First, _InIt _Last, _OutIt _Dest) { // copy [_First, _Last) to [_Dest, ...) _CONSTEXPR20 _OutIt copy(_InIt _First, _InIt _Last, _OutIt _Dest) { // copy [_First, _Last) to [_Dest, ...)
_Adl_verify_range(_First, _Last); _Adl_verify_range(_First, _Last);
const auto _UFirst = _Get_unwrapped(_First); const auto _UFirst = _Get_unwrapped(_First);
const auto _ULast = _Get_unwrapped(_Last); const auto _ULast = _Get_unwrapped(_Last);
@ -3653,7 +3653,7 @@ _CONSTEXPR20_ICE _OutIt copy(_InIt _First, _InIt _Last, _OutIt _Dest) { // copy
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt, class _DestTy, size_t _DestSize> template <class _InIt, class _DestTy, size_t _DestSize>
_CONSTEXPR20_ICE _DestTy* copy(_InIt _First, _InIt _Last, _DestTy (&_Dest)[_DestSize]) { _CONSTEXPR20 _DestTy* copy(_InIt _First, _InIt _Last, _DestTy (&_Dest)[_DestSize]) {
// copy [_First, _Last) to [_Dest, ...) // copy [_First, _Last) to [_Dest, ...)
return _STD copy(_First, _Last, _Array_iterator<_DestTy, _DestSize>(_Dest))._Unwrapped(); return _STD copy(_First, _Last, _Array_iterator<_DestTy, _DestSize>(_Dest))._Unwrapped();
} }
@ -3683,7 +3683,7 @@ _DestTy* copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _DestTy (&_Dest)[_DestSize
// FUNCTION TEMPLATE copy_n // FUNCTION TEMPLATE copy_n
#if _HAS_IF_CONSTEXPR #if _HAS_IF_CONSTEXPR
template <class _InIt, class _Diff, class _OutIt> template <class _InIt, class _Diff, class _OutIt>
_CONSTEXPR20_ICE _OutIt copy_n(_InIt _First, _Diff _Count_raw, _OutIt _Dest) { _CONSTEXPR20 _OutIt copy_n(_InIt _First, _Diff _Count_raw, _OutIt _Dest) {
// copy [_First, _First + _Count) to [_Dest, ...) // copy [_First, _First + _Count) to [_Dest, ...)
_Algorithm_int_t<_Diff> _Count = _Count_raw; _Algorithm_int_t<_Diff> _Count = _Count_raw;
if (0 < _Count) { if (0 < _Count) {
@ -3760,7 +3760,7 @@ _OutIt copy_n(_InIt _First, _Diff _Count_raw, _OutIt _Dest) { // copy [_First, _
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _SourceTy, size_t _SourceSize, class _Diff, class _OutIt> template <class _SourceTy, size_t _SourceSize, class _Diff, class _OutIt>
_CONSTEXPR20_ICE _OutIt copy_n(_SourceTy (&_First)[_SourceSize], _Diff _Count_raw, _OutIt _Dest) { _CONSTEXPR20 _OutIt copy_n(_SourceTy (&_First)[_SourceSize], _Diff _Count_raw, _OutIt _Dest) {
// copy [_First, _First + _Count) to [_Dest, ...), array source // copy [_First, _First + _Count) to [_Dest, ...), array source
const _Algorithm_int_t<_Diff> _Count = _Count_raw; const _Algorithm_int_t<_Diff> _Count = _Count_raw;
if (0 < _Count) { if (0 < _Count) {
@ -3772,7 +3772,7 @@ _CONSTEXPR20_ICE _OutIt copy_n(_SourceTy (&_First)[_SourceSize], _Diff _Count_ra
} }
template <class _InIt, class _Diff, class _DestTy, size_t _DestSize> template <class _InIt, class _Diff, class _DestTy, size_t _DestSize>
_CONSTEXPR20_ICE _DestTy* copy_n(_InIt _First, _Diff _Count_raw, _DestTy (&_Dest)[_DestSize]) { _CONSTEXPR20 _DestTy* copy_n(_InIt _First, _Diff _Count_raw, _DestTy (&_Dest)[_DestSize]) {
// copy [_First, _First + _Count) to [_Dest, ...), array dest // copy [_First, _First + _Count) to [_Dest, ...), array dest
const _Algorithm_int_t<_Diff> _Count = _Count_raw; const _Algorithm_int_t<_Diff> _Count = _Count_raw;
if (0 < _Count) { if (0 < _Count) {
@ -3784,7 +3784,7 @@ _CONSTEXPR20_ICE _DestTy* copy_n(_InIt _First, _Diff _Count_raw, _DestTy (&_Dest
} }
template <class _SourceTy, size_t _SourceSize, class _Diff, class _DestTy, size_t _DestSize> template <class _SourceTy, size_t _SourceSize, class _Diff, class _DestTy, size_t _DestSize>
_CONSTEXPR20_ICE _DestTy* copy_n(_SourceTy (&_First)[_SourceSize], _Diff _Count_raw, _DestTy (&_Dest)[_DestSize]) { _CONSTEXPR20 _DestTy* copy_n(_SourceTy (&_First)[_SourceSize], _Diff _Count_raw, _DestTy (&_Dest)[_DestSize]) {
// copy [_First, _First + _Count) to [_Dest, ...), array source/dest // copy [_First, _First + _Count) to [_Dest, ...), array source/dest
const _Algorithm_int_t<_Diff> _Count = _Count_raw; const _Algorithm_int_t<_Diff> _Count = _Count_raw;
if (0 < _Count) { if (0 < _Count) {
@ -3855,7 +3855,7 @@ _BidIt2 _Copy_backward_memmove(move_iterator<_BidIt1> _First, move_iterator<_Bid
#if _HAS_IF_CONSTEXPR #if _HAS_IF_CONSTEXPR
template <class _BidIt1, class _BidIt2> template <class _BidIt1, class _BidIt2>
_CONSTEXPR20_ICE _BidIt2 copy_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) { _CONSTEXPR20 _BidIt2 copy_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
// copy [_First, _Last) backwards to [..., _Dest) // copy [_First, _Last) backwards to [..., _Dest)
_Adl_verify_range(_First, _Last); _Adl_verify_range(_First, _Last);
const auto _UFirst = _Get_unwrapped(_First); const auto _UFirst = _Get_unwrapped(_First);
@ -3919,7 +3919,7 @@ _BidIt2 copy_backward(_ExPo&&, _BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) noe
// FUNCTION TEMPLATE move // FUNCTION TEMPLATE move
#if _HAS_IF_CONSTEXPR #if _HAS_IF_CONSTEXPR
template <class _InIt, class _OutIt> template <class _InIt, class _OutIt>
_CONSTEXPR20_ICE _OutIt _Move_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest) { _CONSTEXPR20 _OutIt _Move_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest) {
// move [_First, _Last) to [_Dest, ...) // move [_First, _Last) to [_Dest, ...)
// note: _Move_unchecked has callers other than the move family // note: _Move_unchecked has callers other than the move family
if constexpr (_Ptr_move_cat<_InIt, _OutIt>::_Trivially_copyable) { if constexpr (_Ptr_move_cat<_InIt, _OutIt>::_Trivially_copyable) {
@ -3963,7 +3963,7 @@ _OutIt _Move_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest) {
#endif // _HAS_IF_CONSTEXPR #endif // _HAS_IF_CONSTEXPR
template <class _InIt, class _OutIt> template <class _InIt, class _OutIt>
_CONSTEXPR20_ICE _OutIt move(_InIt _First, _InIt _Last, _OutIt _Dest) { _CONSTEXPR20 _OutIt move(_InIt _First, _InIt _Last, _OutIt _Dest) {
// move [_First, _Last) to [_Dest, ...) // move [_First, _Last) to [_Dest, ...)
_Adl_verify_range(_First, _Last); _Adl_verify_range(_First, _Last);
const auto _UFirst = _Get_unwrapped(_First); const auto _UFirst = _Get_unwrapped(_First);
@ -4004,7 +4004,7 @@ _DestTy* move(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _DestTy (&_Dest)[_DestSize
// FUNCTION TEMPLATE move_backward // FUNCTION TEMPLATE move_backward
#if _HAS_IF_CONSTEXPR #if _HAS_IF_CONSTEXPR
template <class _BidIt1, class _BidIt2> template <class _BidIt1, class _BidIt2>
_CONSTEXPR20_ICE _BidIt2 _Move_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) { _CONSTEXPR20 _BidIt2 _Move_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
// move [_First, _Last) backwards to [..., _Dest) // move [_First, _Last) backwards to [..., _Dest)
// note: _Move_backward_unchecked has callers other than the move_backward family // note: _Move_backward_unchecked has callers other than the move_backward family
if constexpr (_Ptr_move_cat<_BidIt1, _BidIt2>::_Trivially_copyable) { if constexpr (_Ptr_move_cat<_BidIt1, _BidIt2>::_Trivially_copyable) {
@ -4049,7 +4049,7 @@ _BidIt2 _Move_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
#endif // _HAS_IF_CONSTEXPR #endif // _HAS_IF_CONSTEXPR
template <class _BidIt1, class _BidIt2> template <class _BidIt1, class _BidIt2>
_CONSTEXPR20_ICE _BidIt2 move_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) { _CONSTEXPR20 _BidIt2 move_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
// move [_First, _Last) backwards to [..., _Dest) // move [_First, _Last) backwards to [..., _Dest)
_Adl_verify_range(_First, _Last); _Adl_verify_range(_First, _Last);
const auto _UFirst = _Get_unwrapped(_First); const auto _UFirst = _Get_unwrapped(_First);
@ -4110,7 +4110,7 @@ _INLINE_VAR constexpr bool _Fill_memset_is_safe<_FwdIt, _Ty, false> = false;
#if _HAS_IF_CONSTEXPR #if _HAS_IF_CONSTEXPR
template <class _FwdIt, class _Ty> template <class _FwdIt, class _Ty>
_CONSTEXPR20_ICE void fill(const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) { _CONSTEXPR20 void fill(const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) {
// copy _Val through [_First, _Last) // copy _Val through [_First, _Last)
_Adl_verify_range(_First, _Last); _Adl_verify_range(_First, _Last);
auto _UFirst = _Get_unwrapped(_First); auto _UFirst = _Get_unwrapped(_First);
@ -4165,7 +4165,7 @@ void fill(_ExPo&&, _FwdIt _First, _FwdIt _Last, const _Ty& _Val) noexcept /* ter
// FUNCTION TEMPLATE fill_n // FUNCTION TEMPLATE fill_n
#if _HAS_IF_CONSTEXPR #if _HAS_IF_CONSTEXPR
template <class _OutIt, class _Diff, class _Ty> template <class _OutIt, class _Diff, class _Ty>
_CONSTEXPR20_ICE _OutIt fill_n(_OutIt _Dest, const _Diff _Count_raw, const _Ty& _Val) { _CONSTEXPR20 _OutIt fill_n(_OutIt _Dest, const _Diff _Count_raw, const _Ty& _Val) {
// copy _Val _Count times through [_Dest, ...) // copy _Val _Count times through [_Dest, ...)
_Algorithm_int_t<_Diff> _Count = _Count_raw; _Algorithm_int_t<_Diff> _Count = _Count_raw;
if (0 < _Count) { if (0 < _Count) {
@ -4287,7 +4287,7 @@ typename _Equal_memcmp_is_safe_helper<remove_const_t<_Obj1>, remove_const_t<_Obj
#if _HAS_IF_CONSTEXPR #if _HAS_IF_CONSTEXPR
template <class _InIt1, class _InIt2, class _Pr> template <class _InIt1, class _InIt2, class _Pr>
_NODISCARD _CONSTEXPR20_ICE bool equal(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _Pr _Pred) { _NODISCARD _CONSTEXPR20 bool equal(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _Pr _Pred) {
// compare [_First1, _Last1) to [_First2, ...) using _Pred // compare [_First1, _Last1) to [_First2, ...) using _Pred
_Adl_verify_range(_First1, _Last1); _Adl_verify_range(_First1, _Last1);
auto _UFirst1 = _Get_unwrapped(_First1); auto _UFirst1 = _Get_unwrapped(_First1);
@ -4354,7 +4354,7 @@ _NODISCARD bool equal(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _F
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _RightTy, size_t _RightSize, class _Pr, enable_if_t<!is_same_v<_RightTy*, _Pr>, int> = 0> template <class _InIt1, class _RightTy, size_t _RightSize, class _Pr, enable_if_t<!is_same_v<_RightTy*, _Pr>, int> = 0>
_NODISCARD _CONSTEXPR20_ICE bool equal( _NODISCARD _CONSTEXPR20 bool equal(
const _InIt1 _First1, const _InIt1 _Last1, _RightTy (&_First2)[_RightSize], _Pr _Pred) { const _InIt1 _First1, const _InIt1 _Last1, _RightTy (&_First2)[_RightSize], _Pr _Pred) {
// compare [_First1, _Last1) to [_First2, ...) using _Pred // compare [_First1, _Last1) to [_First2, ...) using _Pred
return _STD equal(_First1, _Last1, _Array_iterator<_RightTy, _RightSize>(_First2), _Pass_fn(_Pred)); return _STD equal(_First1, _Last1, _Array_iterator<_RightTy, _RightSize>(_First2), _Pass_fn(_Pred));
@ -4381,14 +4381,14 @@ _NODISCARD bool equal(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _RightTy (
#endif // _HAS_CXX17 #endif // _HAS_CXX17
template <class _InIt1, class _InIt2> template <class _InIt1, class _InIt2>
_NODISCARD _CONSTEXPR20_ICE bool equal(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2) { _NODISCARD _CONSTEXPR20 bool equal(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2) {
// compare [_First1, _Last1) to [_First2, ...) // compare [_First1, _Last1) to [_First2, ...)
return _STD equal(_First1, _Last1, _First2, equal_to<>()); return _STD equal(_First1, _Last1, _First2, equal_to<>());
} }
#if _ITERATOR_DEBUG_ARRAY_OVERLOADS #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template <class _InIt1, class _RightTy, size_t _RightSize> template <class _InIt1, class _RightTy, size_t _RightSize>
_NODISCARD _CONSTEXPR20_ICE bool equal(const _InIt1 _First1, const _InIt1 _Last1, _RightTy (&_First2)[_RightSize]) { _NODISCARD _CONSTEXPR20 bool equal(const _InIt1 _First1, const _InIt1 _Last1, _RightTy (&_First2)[_RightSize]) {
// compare [_First1, _Last1) to [_First2, ...) // compare [_First1, _Last1) to [_First2, ...)
return _STD equal(_First1, _Last1, _First2, equal_to<>()); return _STD equal(_First1, _Last1, _First2, equal_to<>());
} }
@ -4414,7 +4414,7 @@ _NODISCARD bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1
#if _HAS_IF_CONSTEXPR #if _HAS_IF_CONSTEXPR
template <class _InIt1, class _InIt2, class _Pr> template <class _InIt1, class _InIt2, class _Pr>
_NODISCARD _CONSTEXPR20_ICE bool equal( _NODISCARD _CONSTEXPR20 bool equal(
const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) { const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
// compare [_First1, _Last1) to [_First2, _Last2) using _Pred // compare [_First1, _Last1) to [_First2, _Last2) using _Pred
_Adl_verify_range(_First1, _Last1); _Adl_verify_range(_First1, _Last1);
@ -4499,7 +4499,7 @@ _NODISCARD bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1
#endif // _HAS_CXX17 #endif // _HAS_CXX17
template <class _InIt1, class _InIt2> template <class _InIt1, class _InIt2>
_NODISCARD _CONSTEXPR20_ICE bool equal( _NODISCARD _CONSTEXPR20 bool equal(
const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2) { const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2) {
// compare [_First1, _Last1) to [_First2, _Last2) // compare [_First1, _Last1) to [_First2, _Last2)
return _STD equal(_First1, _Last1, _First2, _Last2, equal_to<>()); return _STD equal(_First1, _Last1, _First2, _Last2, equal_to<>());
@ -4585,7 +4585,7 @@ _NODISCARD constexpr bool _Lex_compare_unchecked(
} }
template <class _InIt1, class _InIt2, class _Pr, class _Memcmp_pr> template <class _InIt1, class _InIt2, class _Pr, class _Memcmp_pr>
_NODISCARD _CONSTEXPR20_ICE bool _Lex_compare_unchecked( _NODISCARD _CONSTEXPR20 bool _Lex_compare_unchecked(
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred, _Lex_compare_optimize<_Memcmp_pr>) { _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred, _Lex_compare_optimize<_Memcmp_pr>) {
// order [_First1, _Last1) vs. [_First2, _Last2) memcmp optimization // order [_First1, _Last1) vs. [_First2, _Last2) memcmp optimization
#ifdef __cpp_lib_is_constant_evaluated #ifdef __cpp_lib_is_constant_evaluated
@ -4601,7 +4601,7 @@ _NODISCARD _CONSTEXPR20_ICE bool _Lex_compare_unchecked(
} }
template <class _InIt1, class _InIt2, class _Pr> template <class _InIt1, class _InIt2, class _Pr>
_NODISCARD _CONSTEXPR20_ICE bool lexicographical_compare( _NODISCARD _CONSTEXPR20 bool lexicographical_compare(
_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred) { _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred) {
// order [_First1, _Last1) vs. [_First2, _Last2) using _Pred // order [_First1, _Last1) vs. [_First2, _Last2) using _Pred
_Adl_verify_range(_First1, _Last1); _Adl_verify_range(_First1, _Last1);
@ -4615,7 +4615,7 @@ _NODISCARD _CONSTEXPR20_ICE bool lexicographical_compare(
} }
template <class _InIt1, class _InIt2> template <class _InIt1, class _InIt2>
_NODISCARD _CONSTEXPR20_ICE bool lexicographical_compare(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2) { _NODISCARD _CONSTEXPR20 bool lexicographical_compare(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2) {
// order [_First1, _Last1) vs. [_First2, _Last2) // order [_First1, _Last1) vs. [_First2, _Last2)
return _STD lexicographical_compare(_First1, _Last1, _First2, _Last2, less<>()); return _STD lexicographical_compare(_First1, _Last1, _First2, _Last2, less<>());
} }
@ -4696,7 +4696,7 @@ _NODISCARD constexpr _InIt _Find_unchecked1(_InIt _First, const _InIt _Last, con
} }
template <class _InIt, class _Ty> template <class _InIt, class _Ty>
_NODISCARD _CONSTEXPR20_ICE _InIt _Find_unchecked1(_InIt _First, const _InIt _Last, const _Ty& _Val, true_type) { _NODISCARD _CONSTEXPR20 _InIt _Find_unchecked1(_InIt _First, const _InIt _Last, const _Ty& _Val, true_type) {
// find first byte matching integral _Val // find first byte matching integral _Val
if (!_Within_limits(_First, _Val)) { if (!_Within_limits(_First, _Val)) {
return _Last; return _Last;
@ -4713,7 +4713,7 @@ _NODISCARD _CONSTEXPR20_ICE _InIt _Find_unchecked1(_InIt _First, const _InIt _La
} }
template <class _InIt, class _Ty> template <class _InIt, class _Ty>
_NODISCARD _CONSTEXPR20_ICE _InIt _Find_unchecked(const _InIt _First, const _InIt _Last, const _Ty& _Val) { _NODISCARD _CONSTEXPR20 _InIt _Find_unchecked(const _InIt _First, const _InIt _Last, const _Ty& _Val) {
// find first matching _Val; choose optimization // find first matching _Val; choose optimization
// activate optimization for pointers to (const) bytes and integral values // activate optimization for pointers to (const) bytes and integral values
using _Memchr_opt = bool_constant< using _Memchr_opt = bool_constant<
@ -4724,7 +4724,7 @@ _NODISCARD _CONSTEXPR20_ICE _InIt _Find_unchecked(const _InIt _First, const _InI
} }
template <class _InIt, class _Ty> template <class _InIt, class _Ty>
_NODISCARD _CONSTEXPR20_ICE _InIt find(_InIt _First, const _InIt _Last, const _Ty& _Val) { // find first matching _Val _NODISCARD _CONSTEXPR20 _InIt find(_InIt _First, const _InIt _Last, const _Ty& _Val) { // find first matching _Val
_Adl_verify_range(_First, _Last); _Adl_verify_range(_First, _Last);
_Seek_wrapped(_First, _Find_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Val)); _Seek_wrapped(_First, _Find_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Val));
return _First; return _First;
@ -4969,7 +4969,7 @@ _NODISCARD _CONSTEXPR20 bool is_permutation(_FwdIt1 _First1, _FwdIt1 _Last1, _Fw
// FUNCTION TEMPLATE reverse // FUNCTION TEMPLATE reverse
#if _HAS_IF_CONSTEXPR #if _HAS_IF_CONSTEXPR
template <class _BidIt> template <class _BidIt>
_CONSTEXPR20_ICE void reverse(const _BidIt _First, const _BidIt _Last) { // reverse elements in [_First, _Last) _CONSTEXPR20 void reverse(const _BidIt _First, const _BidIt _Last) { // reverse elements in [_First, _Last)
_Adl_verify_range(_First, _Last); _Adl_verify_range(_First, _Last);
auto _UFirst = _Get_unwrapped(_First); auto _UFirst = _Get_unwrapped(_First);
auto _ULast = _Get_unwrapped(_Last); auto _ULast = _Get_unwrapped(_Last);

45
stl/inc/yvals_core.h
Просмотреть файл

@ -1019,47 +1019,32 @@
#endif // _HAS_STD_BOOLEAN #endif // _HAS_STD_BOOLEAN
#endif // defined(__cpp_concepts) && __cpp_concepts > 201507L #endif // defined(__cpp_concepts) && __cpp_concepts > 201507L
#define __cpp_lib_constexpr_algorithms 201806L
#define __cpp_lib_constexpr_memory 201811L #define __cpp_lib_constexpr_memory 201811L
#define __cpp_lib_constexpr_numeric 201911L
#define __cpp_lib_endian 201907L #define __cpp_lib_endian 201907L
#define __cpp_lib_erase_if 201811L #define __cpp_lib_erase_if 201811L
#define __cpp_lib_generic_unordered_lookup 201811L #define __cpp_lib_generic_unordered_lookup 201811L
#define __cpp_lib_int_pow2 201806L #define __cpp_lib_int_pow2 201806L
#define __cpp_lib_is_constant_evaluated 201811L
#if defined(__clang__) || defined(__EDG__) || (defined(_MSC_VER) && _MSC_VER >= 1925) #define __cpp_lib_is_nothrow_convertible 201806L
#define __cpp_lib_is_constant_evaluated 201811L #define __cpp_lib_list_remove_return_type 201806L
#endif // TRANSITION, VS 2019 16.5 Preview 2 #define __cpp_lib_math_constants 201907L
#define __cpp_lib_remove_cvref 201711L
#define __cpp_lib_is_nothrow_convertible 201806L #define __cpp_lib_shift 201806L
#define __cpp_lib_list_remove_return_type 201806L #define __cpp_lib_span 201902L
#define __cpp_lib_math_constants 201907L #define __cpp_lib_ssize 201902L
#define __cpp_lib_remove_cvref 201711L #define __cpp_lib_starts_ends_with 201711L
#define __cpp_lib_shift 201806L #define __cpp_lib_to_address 201711L
#define __cpp_lib_span 201902L #define __cpp_lib_to_array 201907L
#define __cpp_lib_ssize 201902L #define __cpp_lib_type_identity 201806L
#define __cpp_lib_starts_ends_with 201711L #define __cpp_lib_unwrap_ref 201811L
#define __cpp_lib_to_address 201711L
#define __cpp_lib_to_array 201907L
#define __cpp_lib_type_identity 201806L
#define __cpp_lib_unwrap_ref 201811L
#ifdef __cpp_lib_is_constant_evaluated
#define __cpp_lib_constexpr_algorithms 201806L
#define __cpp_lib_constexpr_numeric 201911L
#endif // __cpp_lib_is_constant_evaluated
#endif // _HAS_CXX20 #endif // _HAS_CXX20
// EXPERIMENTAL // EXPERIMENTAL
#define __cpp_lib_experimental_erase_if 201411L #define __cpp_lib_experimental_erase_if 201411L
#define __cpp_lib_experimental_filesystem 201406L #define __cpp_lib_experimental_filesystem 201406L
// Functions that became constexpr in C++20, and require is_constant_evaluated
#ifdef __cpp_lib_is_constant_evaluated
#define _CONSTEXPR20_ICE constexpr
#else // ^^^ constexpr with is_constant_evaluated / inline without is_constant_evaluated vvv
#define _CONSTEXPR20_ICE inline
#endif // __cpp_lib_is_constant_evaluated
#ifdef _RTC_CONVERSION_CHECKS_ENABLED #ifdef _RTC_CONVERSION_CHECKS_ENABLED
#ifndef _ALLOW_RTCc_IN_STL #ifndef _ALLOW_RTCc_IN_STL
#error /RTCc rejects conformant code, so it is not supported by the C++ Standard Library. Either remove this \ #error /RTCc rejects conformant code, so it is not supported by the C++ Standard Library. Either remove this \