From 6585715564b6570ec8c9f5fd14781f79983a6a4d Mon Sep 17 00:00:00 2001 From: Tyler Date: Mon, 15 Aug 2022 15:01:16 -0700 Subject: [PATCH 01/91] Added the std::views::zip implementation. --- stl/inc/ranges | 631 +++++++++++++++++++++++++++++++++++++++++++ stl/inc/yvals_core.h | 1 + 2 files changed, 632 insertions(+) diff --git a/stl/inc/ranges b/stl/inc/ranges index 7867209e7ba..553cc831988 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6837,6 +6837,637 @@ namespace ranges { inline constexpr _Stride_fn stride; } // namespace views +#ifdef __cpp_lib_ranges_zip + template + concept _Zip_is_common = (sizeof...(_RangeTypes) == 1 && (_RANGES common_range<_RangeTypes> && ...)) // + || (!(_RANGES bidirectional_range<_RangeTypes> && ...) && (_RANGES common_range<_RangeTypes> && ...)) // + || ((_RANGES random_access_range<_RangeTypes> && ...) && (_RANGES sized_range<_RangeTypes> && ...)); + + template + using _Zip_tuple_or_pair = _STD conditional_t<(sizeof...(_RangeTypes) == 2), _STD pair<_RangeTypes...>, _STD tuple<_RangeTypes...>>; + + template + constexpr auto _Zip_create_tuple_transform_lambda(_CallbackType&& _Callback) noexcept { + const auto _Created_lambda = [&_Callback](_ViewTupleTypes&&... _View_tuples) { + return _Zip_tuple_or_pair<_STD invoke_result_t<_CallbackType&, _ViewTupleTypes>...>{ + _STD invoke(_Callback, _STD forward<_ViewTupleTypes>(_View_tuples))...}; + }; + + return _Created_lambda; + } + + template + constexpr auto _Zip_tuple_transform(_CallbackType&& _Callback, _TupleType&& _Tuple) noexcept( + noexcept(_STD apply(_Zip_create_tuple_transform_lambda(_STD forward<_CallbackType>(_Callback)), + _STD forward<_TupleType>(_Tuple)))) /* strengthened */ { + return _STD apply(_Zip_create_tuple_transform_lambda(_STD forward<_CallbackType>(_Callback)), + _STD forward<_TupleType>(_Tuple)); + } + + template + constexpr auto _Zip_create_tuple_for_each_lambda(_CallbackType&& _Callback) noexcept { + const auto _Created_lambda = [&_Callback](_ViewTupleTypes&&... _View_tuples) { + (_STD invoke(_Callback, _STD forward<_ViewTupleTypes>(_View_tuples)), ...); + }; + + return _Created_lambda; + } + + template + constexpr void _Zip_tuple_for_each(_CallbackType&& _Callback, _TupleType&& _Tuple) noexcept(noexcept(_STD apply(_Zip_create_tuple_for_each_lambda(_STD forward<_CallbackType>(_Callback)), + _STD forward<_TupleType>(_Tuple)))) /* strengthened */ { + _STD apply(_Zip_create_tuple_for_each_lambda(_STD forward<_CallbackType>(_Callback)), + _STD forward<_TupleType>(_Tuple)); + } + + template + concept _Zip_all_random_access = (_RANGES random_access_range<_Maybe_const<_IsConst, _Views>> && ...); + + template + concept _Zip_all_bidirectional = (_RANGES bidirectional_range<_Maybe_const<_IsConst, _Views>> && ...); + + template + concept _Zip_all_forward = (_RANGES forward_range<_Maybe_const<_IsConst, _Views>> && ...); + + template + concept _Zip_allow_views = (_RANGES input_range<_ViewTypes> && ...) && (_RANGES view<_ViewTypes> && ...) + && (sizeof...(_ViewTypes) > 0); + + template <_RANGES input_range... _ViewTypes> + requires _Zip_allow_views<_ViewTypes...> + class zip_view : public _RANGES view_interface> { + public: + template + class _Iterator; + + template + class _Sentinel; + + private: + template + friend class _Sentinel; + + template + struct _Iterator_category_container {}; + + template + requires _Zip_all_forward<_IsConst, _ViewTypes...> + struct _Iterator_category_container<_Iterator<_IsConst>> { + using iterator_category = _STD input_iterator_tag; + }; + + public: + zip_view() noexcept((_STD is_nothrow_default_constructible_v<_ViewTypes> && ...)) = default; + + constexpr explicit zip_view(_ViewTypes... _Views) noexcept( + (_STD is_nothrow_move_constructible_v<_ViewTypes> && ...)) // strengthened + : _M_Views(_STD move(_Views)...) {} + + _NODISCARD constexpr auto begin() noexcept( + noexcept(_Zip_tuple_transform(_RANGES begin, _M_Views))) // strengthened + requires(!(_Simple_view<_ViewTypes> && ...)) { + return _Iterator{_Zip_tuple_transform(_RANGES begin, _M_Views)}; + } + + _NODISCARD constexpr auto begin() const noexcept( + noexcept(_Zip_tuple_transform(_RANGES begin, _M_Views))) // strengthened + requires(_RANGES range&&...) { + return _Iterator{_Zip_tuple_transform(_RANGES begin, _M_Views)}; + } + + _NODISCARD constexpr auto end() noexcept(noexcept(_Sentinel{ + _Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept(_Iterator{_Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept(_RANGES next(begin(), + _STD iter_difference_t<_Iterator>{_Get_signed_size()}))) // strengthened + requires(!(_Simple_view<_ViewTypes> && ...)) { + if constexpr (!_Zip_is_common<_ViewTypes...>) { + return _Sentinel{_Zip_tuple_transform(_RANGES end, _M_Views)}; + } + else if constexpr ((_RANGES random_access_range<_ViewTypes> && ...)){ + return (begin() + _STD iter_difference_t<_Iterator>{_Get_signed_size()}); + } else { + return _Iterator{_Zip_tuple_transform(_RANGES end, _M_Views)}; + } + } + + _NODISCARD constexpr auto end() const noexcept(noexcept(_Sentinel{ + _Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept(_Iterator{_Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept(_RANGES next(begin(), + _STD iter_difference_t<_Iterator>{_Get_signed_size()}))) // strengthened + requires(_RANGES range && ...) { + if constexpr (!_Zip_is_common) { + return _Sentinel{_Zip_tuple_transform(_RANGES end, _M_Views)}; + } else if constexpr ((_RANGES random_access_range && ...)) { + return (begin() + _STD iter_difference_t<_Iterator>{_Get_signed_size()}); + } else { + return _Iterator{_Zip_tuple_transform(_RANGES end, _M_Views)}; + } + } + + _NODISCARD constexpr auto size() noexcept(noexcept(_Zip_tuple_for_each(_RANGES size, _M_Views))) // strengthened + requires (_RANGES sized_range<_ViewTypes> && ...) { + using _Common_size_type = _STD common_type_t<_RANGES range_size_t<_ViewTypes>...>; + using _Common_unsigned_size_type = _Make_unsigned_like_t<_Common_size_type>; + + auto _Smallest_view_size_value = _STD numeric_limits<_Common_unsigned_size_type>::max(); + + _Zip_tuple_for_each( + [&_Smallest_view_size_value](_View& _Curr_view) { + const auto _Curr_view_size_value = + static_cast<_Common_unsigned_size_type>(_RANGES size(_Curr_view)); + + if (_Curr_view_size_value < _Smallest_view_size_value) + _Smallest_view_size_value = _Curr_view_size_value; + }, + _M_Views); + + return _Smallest_view_size_value; + } + + _NODISCARD constexpr auto size() const noexcept(noexcept(_Zip_tuple_for_each(_RANGES size, _M_Views))) // strengthened + requires(_RANGES sized_range && ...) { + using _Common_size_type = _STD common_type_t<_RANGES range_size_t<_ViewTypes>...>; + using _Common_unsigned_size_type = _Make_unsigned_like_t<_Common_size_type>; + + auto _Smallest_view_size_value = _STD numeric_limits<_Common_unsigned_size_type>::max(); + + _Zip_tuple_for_each( + [&_Smallest_view_size_value](const _View& _Curr_view) { + const auto _Curr_view_size_value = + static_cast<_Common_unsigned_size_type>(_RANGES size(_Curr_view)); + + if (_Curr_view_size_value < _Smallest_view_size_value) + _Smallest_view_size_value = _Curr_view_size_value; + }, + _M_Views); + + return _Smallest_view_size_value; + } + + private: + _NODISCARD constexpr auto _Get_signed_size() noexcept(noexcept(size())) { + const auto _Possibly_unsigned_size = size(); + + if constexpr (_STD is_unsigned_v) { + return static_cast<_Make_signed_like_t>(_Possibly_unsigned_size); + } else { + return _Possibly_unsigned_size; + } + } + + _NODISCARD constexpr auto _Get_signed_size() const noexcept(noexcept(size())) { + const auto _Possibly_unsigned_size = size(); + + if constexpr (_STD is_unsigned_v) { + return static_cast<_Make_signed_like_t>(_Possibly_unsigned_size); + } else { + return _Possibly_unsigned_size; + } + } + + private: + _Zip_tuple_or_pair<_ViewTypes...> _M_Views; + }; + + template + zip_view(_RangeTypes&&...) -> zip_view<_RANGES views::all_t<_RangeTypes>...>; + + template <_RANGES input_range... _RangeTypes> + inline constexpr bool enable_borrowed_range> = + (_RANGES enable_borrowed_range<_RangeTypes> && ...); + + template + requires _Zip_allow_views<_ViewTypes...> _NODISCARD constexpr bool _Zip_iterator_sentinel_equality_impl( + const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, + const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& + _Rhs); + + template + requires _Zip_allow_views<_ViewTypes...> + _NODISCARD constexpr _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...> + _Zip_get_smallest_iterator_sentinel_distance_impl( + const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, + const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& + _Rhs); + + template <_RANGES input_range... _ViewTypes> + requires _Zip_allow_views<_ViewTypes...> + template + class zip_view<_ViewTypes...>::_Iterator : public _Iterator_category_container<_Iterator<_IsConst>> { + private: + friend class zip_view<_ViewTypes...>; + + template + requires _Zip_allow_views<_Views...> _NODISCARD_FRIEND constexpr bool _Zip_iterator_sentinel_equality_impl( + const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, + const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& + _Rhs); + + template + requires _Zip_allow_views<_Views...> _NODISCARD_FRIEND constexpr _STD + common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _Views>>...> + _Zip_get_smallest_iterator_sentinel_distance_impl( + const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, + const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& + _Rhs); + + using _Iterator_tuple_type = _Zip_tuple_or_pair<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>...>; + + constexpr explicit _Iterator(_Iterator_tuple_type _Current) noexcept( + _STD is_nothrow_move_constructible_v<_Iterator_tuple_type>) + : _M_Current(_STD move(_Current)) {} + + static constexpr bool _Is_nothrow_dereferenceable = + (noexcept(*(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())) && ...); + + static constexpr bool _Is_nothrow_preincrementable = + (noexcept(++(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())) && ...); + + static constexpr bool _Is_nothrow_predecrementable = + (noexcept(--(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())) && ...); + + public: + // NOTE: iterator_category is conditionally present based on whether or not it exists as + // a type alias in _Iterator_category_container. + + using iterator_concept = + _STD conditional_t<_Zip_all_random_access<_IsConst, _ViewTypes...>, _STD random_access_iterator_tag, + _STD conditional_t<_Zip_all_bidirectional<_IsConst, _ViewTypes...>, _STD bidirectional_iterator_tag, + _STD conditional_t<_Zip_all_forward<_IsConst, _ViewTypes...>, _STD forward_iterator_tag, + _STD input_iterator_tag>>>; + + using value_type = _Zip_tuple_or_pair<_RANGES range_value_t<_Maybe_const<_IsConst, _ViewTypes>>...>; + using difference_type = _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IsConst, _ViewTypes>>...>; + + _Iterator() noexcept(_STD is_nothrow_default_constructible_v<_Iterator_tuple_type>) = default; + + constexpr _Iterator(_Iterator _Rhs) noexcept( + (_STD is_nothrow_move_constructible_v< + _RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) // strengthened + requires(_IsConst + && (_STD convertible_to<_RANGES iterator_t<_ViewTypes>, + _RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) + : _M_Current(_STD move(_Rhs._M_Current)) {} + + _NODISCARD constexpr auto operator*() const noexcept(_Is_nothrow_dereferenceable) /* strengthened */ { + return _Zip_tuple_transform([](auto& _Itr) { return *_Itr; }, _M_Current); + } + + constexpr _Iterator& operator++() noexcept(_Is_nothrow_preincrementable) /* strengthened */ { + _Zip_tuple_for_each([](auto& _Itr) { ++_Itr; }, _M_Current); + return *this; + } + + constexpr void operator++(int) noexcept(_Is_nothrow_preincrementable) /* strengthened */ { + ++(*this); + } + + constexpr _Iterator operator++(int) noexcept(_Is_nothrow_preincrementable && _STD is_nothrow_copy_assignable_v<_Iterator<_IsConst>>) // strengthened + requires _Zip_all_forward<_IsConst, _ViewTypes...> { + const auto _Temp = *this; + ++(*this); + + return _Temp; + } + + constexpr _Iterator& operator--() noexcept(_Is_nothrow_predecrementable) // strengthened + requires _Zip_all_bidirectional<_IsConst, _ViewTypes...> { + _Zip_tuple_for_each([](auto& _Itr) { --_Itr; }, _M_Current); + return *this; + } + + constexpr _Iterator operator--(int) noexcept(_Is_nothrow_predecrementable && _STD is_nothrow_copy_assignable_v<_Iterator<_IsConst>>) // strengthened + requires _Zip_all_bidirectional<_IsConst, _ViewTypes...> { + const auto _Temp = *this; + --(*this); + + return _Temp; + } + + constexpr _Iterator& operator+=(difference_type _X) noexcept( + (noexcept(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>() += + _STD iter_difference_t<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>{_X}) + && ...)) // strengthened + requires _Zip_all_random_access<_IsConst, _ViewTypes...> { + _Zip_tuple_for_each([&_X]( + _IteratorType& _Itr) { _Itr += _STD iter_difference_t<_IteratorType>{_X}; }, + _M_Current); + + return *this; + } + + constexpr _Iterator& operator-=(difference_type _X) noexcept( + (noexcept(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>() -= + _STD iter_difference_t<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>{_X}) + && ...)) // strengthened + requires _Zip_all_random_access<_IsConst, _ViewTypes...> { + _Zip_tuple_for_each([&_X]( + _IteratorType& _Itr) { _Itr -= _STD iter_difference_t<_IteratorType>{_X}; }, + _M_Current); + + return *this; + } + + _NODISCARD constexpr auto operator[](difference_type _X) const noexcept( + (noexcept((_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())[_STD + iter_difference_t<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>{_X}]) + && ...)) // strengthened + requires _Zip_all_random_access<_IsConst, _ViewTypes...> + { + return _Zip_tuple_transform( + [&_X]( + _IteratorType& _Itr) { return _Itr[_STD iter_difference_t<_IteratorType>{_X}]; }, + _M_Current); + } + + _NODISCARD_FRIEND constexpr bool operator==( + const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept(noexcept(_Lhs._M_Current == _Rhs._M_Current)) // strengthened + requires (_STD equality_comparable<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...) + { + if constexpr (_Zip_all_bidirectional<_IsConst, _ViewTypes...>) { + return (_Lhs._M_Current == _Rhs._M_Current); + } else { + const auto _Compare_elements_lambda = [&_Lhs, &_Rhs]<_STD size_t _CurrIndex>(this const auto& self) { + if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { + if (_STD get<_CurrIndex>(_Lhs._M_Current) == _STD get<_CurrIndex>(_Rhs._M_Current)) + return true; + + static constexpr auto _Next_index = (_CurrIndex + 1); + self.operator()<_Next_index>(); + } else { + return false; + } + }; + + return _Compare_elements_lambda.operator()<0>(); + } + } + + _NODISCARD_FRIEND constexpr auto operator<=>(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept(noexcept(_Lhs._M_Current <=> _Rhs._M_Current)) // strengthened + requires _Zip_all_random_access<_IsConst, _ViewTypes...> { + return (_Lhs._M_Current <=> _Rhs._M_Current); + } + + _NODISCARD_FRIEND constexpr _Iterator operator+(const _Iterator& _Lhs, difference_type _Rhs) noexcept( + noexcept(_STD declval<_Iterator>() += _Rhs) && _STD is_nothrow_copy_assignable_v<_Iterator>) // strengthened + requires _Zip_all_random_access<_IsConst, _ViewTypes...> + { + auto _Modified_iterator = _Lhs; + _Modified_iterator += _Rhs; + + return _Modified_iterator; + } + + _NODISCARD_FRIEND constexpr _Iterator operator+(difference_type _Lhs, const _Iterator& _Rhs) noexcept( + noexcept(_Rhs + _Lhs)) /* strengthened */ requires _Zip_all_random_access<_IsConst, _ViewTypes...> { + return (_Rhs + _Lhs); + } + + _NODISCARD_FRIEND constexpr _Iterator operator-(const _Iterator& _Lhs, difference_type _Rhs) noexcept( + noexcept(_STD declval<_Iterator>() -= _Rhs) && _STD is_nothrow_copy_assignable_v<_Iterator>) // strengthened + requires _Zip_all_random_access<_IsConst, _ViewTypes...> + { + auto _Modified_iterator = _Lhs; + _Modified_iterator -= _Rhs; + + return _Modified_iterator; + } + + _NODISCARD_FRIEND constexpr difference_type operator-(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( + (noexcept(difference_type{_RANGES distance(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), + _STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())}) && ...) && noexcept(_STD declval() < _STD declval()) && _STD is_nothrow_copy_assignable_v) // strengthened + requires(_STD sized_sentinel_for<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>, + _RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...) { + if constexpr (sizeof...(_ViewTypes) == 1) { + return difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_Current)}; + } else { + auto _Smallest_difference_value = + difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_Current)}; + auto _Smallest_abs_difference_value = + difference_type{_RANGES distance(_STD get<0>(_Lhs._M_Current), _STD get<0>(_Rhs._M_Current))}; + + const auto _Evaluate_Distances_Lambda = [&_Lhs, &_Rhs, &_Smallest_difference_value, + &_Smallest_abs_difference_value]<_STD size_t _CurrIndex>( + this const auto& self) { + if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { + const auto _Curr_difference_value = difference_type{ + _STD get<_CurrIndex>(_Lhs._M_Current) - _STD get<_CurrIndex>(_Rhs._M_Current)}; + const auto _Curr_abs_difference_value = difference_type{_RANGES distance( + _STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_Current))}; + + if (_Curr_abs_difference_value < _Smallest_abs_difference_value) { + _Smallest_difference_value = _Curr_difference_value; + _Smallest_abs_difference_value = _Curr_abs_difference_value; + } + + static constexpr auto _Next_index = (_CurrIndex + 1); + self.operator()<_Next_index>(); + } + }; + + // Start from index 1, since we already evaluated 0. + _Evaluate_Distances_Lambda.operator()<1>(); + + return _Smallest_difference_value; + } + } + + _NODISCARD_FRIEND constexpr auto iter_move(const _Iterator& _Itr) noexcept( + (noexcept(_RANGES iter_move(_STD declval>&>())) + && ...) + && (_STD is_nothrow_move_constructible_v< + _RANGES range_rvalue_reference_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) { + return _Zip_tuple_transform(_RANGES iter_move, _Itr._M_Current); + } + + friend constexpr void iter_swap(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( + (noexcept(_RANGES iter_swap(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), + _STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())) + && ...)) requires(_STD indirectly_swappable<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...) { + const auto _Perform_swap_lambda = [&_Lhs, &_Rhs]<_STD size_t _CurrIndex>(this const auto& self) { + if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { + _RANGES iter_swap(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_Current)); + + static constexpr auto _Next_index = (_CurrIndex + 1); + self.operator()<_Next_index>(); + } + }; + + _Perform_swap_lambda.operator()<0>(); + } + + private: + _Iterator_tuple_type _M_Current; + }; + + template <_RANGES input_range... _ViewTypes> + requires _Zip_allow_views<_ViewTypes...> + template + class zip_view<_ViewTypes...>::_Sentinel { + private: + friend class zip_view<_ViewTypes...>; + + template + requires _Zip_allow_views<_Views...> _NODISCARD_FRIEND constexpr bool _Zip_iterator_sentinel_equality_impl( + const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, + const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& + _Rhs); + + template + requires _Zip_allow_views<_Views...> _NODISCARD_FRIEND constexpr _STD + common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _Views>>...> + _Zip_get_smallest_iterator_sentinel_distance_impl( + const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, + const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& + _Rhs); + + using _Sentinel_tuple_type = _Zip_tuple_or_pair<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>...>; + + constexpr explicit _Sentinel(_Sentinel_tuple_type _End) noexcept( + _STD is_nothrow_copy_assignable_v<_Sentinel_tuple_type>) // strengthened + : _M_End(_End) {} + + template + using _Iterator_sentinel_difference_type = _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>; + + template + static constexpr bool _Zip_iterator_sentinel_equality_noexcept = + (noexcept(_STD declval<_RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>() + == _STD declval<_RANGES sentinel_t<_Maybe_const<_SentinelConst, _ViewTypes>>>()) + && ...); + + template + static constexpr bool _Zip_get_smallest_iterator_sentinel_distance_noexcept = + (noexcept(_STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>{ + _RANGES distance(_STD declval<_RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>(), + _STD declval<_RANGES sentinel_t<_Maybe_const<_SentinelConst, _ViewTypes>>>())}) + && ...) && noexcept(_STD declval<_STD common_type_t<_RANGES + range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>>() + < _STD declval<_STD common_type_t< + _RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>>()) + && _STD is_nothrow_copy_assignable_v< + _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>>; + + public: + _Sentinel() noexcept(_STD is_nothrow_default_constructible_v<_Sentinel_tuple_type>) = default; + + constexpr _Sentinel(_Sentinel _Rhs) noexcept(_STD is_nothrow_move_constructible_v<_Sentinel_tuple_type>) // strengthened + requires(_IsConst + && (_STD convertible_to<_RANGES sentinel_t<_ViewTypes>, + _RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) + : _M_End(_STD move(_Rhs._M_End)) {} + + template + requires(_STD sentinel_for<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>, _RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>> && ...) + _NODISCARD_FRIEND constexpr bool operator==( + const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, + const _Sentinel& _Rhs) noexcept(_Zip_iterator_sentinel_equality_noexcept<_IsConst, + _IteratorConst, _ViewTypes...>) /* strengthened */ { + return _Zip_iterator_sentinel_equality_impl<_IsConst, _IteratorConst, _ViewTypes...>(_Lhs, _Rhs); + } + + template + requires (_STD sized_sentinel_for<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>, + _RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>> && ...) + _NODISCARD_FRIEND constexpr _Iterator_sentinel_difference_type<_IteratorConst> operator-( + const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, + const _Sentinel& _Rhs) noexcept(_Zip_get_smallest_iterator_sentinel_distance_noexcept<_IsConst, + _IteratorConst, _ViewTypes...>) /* strengthened */ { + return _Zip_get_smallest_iterator_sentinel_distance_impl<_IsConst, _IteratorConst, _ViewTypes...>( + _Lhs, _Rhs); + } + + template + requires(_STD sized_sentinel_for<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>, + _RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>> && ...) + _NODISCARD_FRIEND constexpr _Iterator_sentinel_difference_type<_IteratorConst> operator-(const _Sentinel& _Lhs, + const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& + _Rhs) noexcept(noexcept(-(_Rhs - _Lhs))) /* strengthened */ { + return -(_Rhs - _Lhs); + } + + private: + _Sentinel_tuple_type _M_End; + }; + + template + requires _Zip_allow_views<_ViewTypes...> _NODISCARD constexpr bool _Zip_iterator_sentinel_equality_impl( + const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, + const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& + _Rhs) { + const auto _Evaluate_tuple_values_lambda = [&_Lhs, &_Rhs]<_STD size_t _CurrIndex>(this const auto& self) { + if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { + if (_STD get<_CurrIndex>(_Lhs._M_Current) == _STD get<_CurrIndex>(_Rhs._M_End)) + return true; + + static constexpr auto _Next_index = (_CurrIndex + 1); + return self.operator()<_Next_index>(); + } else { + return false; + } + }; + + return _Evaluate_tuple_values_lambda.operator()<0>(); + } + + template + requires _Zip_allow_views<_ViewTypes...> _NODISCARD constexpr _STD + common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...> + _Zip_get_smallest_iterator_sentinel_distance_impl( + const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, + const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& + _Rhs) { + using _Difference_type = + _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>; + + if constexpr (sizeof...(_ViewTypes) == 1) { + return _Difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_End)}; + } else { + auto _Smallest_distance_value = _Difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_End)}; + auto _Smallest_abs_distance_value = + _RANGES distance(_STD get<0>(_Lhs._M_Current), _STD get<0>(_Rhs._M_End)); + + const auto _Evaluate_distance_values_lambda = [&_Lhs, &_Rhs, &_Smallest_distance_value, + &_Smallest_abs_distance_value]<_STD size_t _CurrIndex>( + this const auto& self) { + const auto _Curr_distance_value = + _Difference_type{_STD get<_CurrIndex>(_Lhs._M_Current) - _STD get<_CurrIndex>(_Rhs._M_End)}; + const auto _Curr_abs_distance_value = + _RANGES distance(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_End)); + + if (_Curr_abs_distance_value < _Smallest_abs_distance_value) { + _Smallest_distance_value = _Curr_distance_value; + _Smallest_abs_distance_value = _Curr_abs_distance_value; + } + + static constexpr auto _Next_index = (_CurrIndex + 1); + self.operator()<_Next_index>(); + }; + + _Evaluate_distance_values_lambda.operator()<0>(); + + return _Smallest_distance_value; + } + } + + namespace views { + class _Zip_function{ + public: + _Zip_function() noexcept = default; + + template <_RANGES input_range... _ViewTypes> + constexpr auto operator()(_ViewTypes&&... _Views) const noexcept(noexcept( + _RANGES views::empty<_STD tuple<>>) && noexcept(zip_view{ _STD forward<_ViewTypes>(_Views)... })) { + if constexpr (sizeof...(_ViewTypes) == 0) { + return _RANGES views::empty<_STD tuple<>>; + } else { + return zip_view{_STD forward<_ViewTypes>(_Views)...}; + } + } + }; + + inline constexpr _Zip_function zip{}; + } // namespace views +#endif // __cpp_lib_ranges_zip + #ifdef __cpp_lib_ranges_to_container // clang-format off template diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h index c5253c4ec7f..c4594f2117f 100644 --- a/stl/inc/yvals_core.h +++ b/stl/inc/yvals_core.h @@ -1521,6 +1521,7 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect #define __cpp_lib_ranges_starts_ends_with 202106L #define __cpp_lib_ranges_stride 202207L #define __cpp_lib_ranges_to_container 202202L +#define __cpp_lib_ranges_zip 202208L #endif // __cpp_lib_concepts #define __cpp_lib_spanstream 202106L From 1982609aa9c04d24537748e2b6430a9b9530b102 Mon Sep 17 00:00:00 2001 From: Tyler Date: Mon, 15 Aug 2022 16:08:47 -0700 Subject: [PATCH 02/91] Fixed some rather sneaky errors. --- stl/inc/ranges | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 553cc831988..552cdd6ee1e 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6844,7 +6844,20 @@ namespace ranges { || ((_RANGES random_access_range<_RangeTypes> && ...) && (_RANGES sized_range<_RangeTypes> && ...)); template - using _Zip_tuple_or_pair = _STD conditional_t<(sizeof...(_RangeTypes) == 2), _STD pair<_RangeTypes...>, _STD tuple<_RangeTypes...>>; + struct _Zip_tuple_or_pair_solver + { + using _Storage_type = _STD tuple<_RangeTypes...>; + }; + + template + requires(sizeof...(_RangeTypes) == 2) + struct _Zip_tuple_or_pair_solver<_RangeTypes...> + { + using _Storage_type = _STD pair<_RangeTypes...>; + }; + + template + using _Zip_tuple_or_pair = typename _Zip_tuple_or_pair_solver<_RangeTypes...>::_Storage_type; template constexpr auto _Zip_create_tuple_transform_lambda(_CallbackType&& _Callback) noexcept { @@ -7108,7 +7121,7 @@ namespace ranges { : _M_Current(_STD move(_Rhs._M_Current)) {} _NODISCARD constexpr auto operator*() const noexcept(_Is_nothrow_dereferenceable) /* strengthened */ { - return _Zip_tuple_transform([](auto& _Itr) { return *_Itr; }, _M_Current); + return _Zip_tuple_transform([](auto& _Itr) -> decltype(auto) { return *_Itr; }, _M_Current); } constexpr _Iterator& operator++() noexcept(_Is_nothrow_preincrementable) /* strengthened */ { @@ -7174,7 +7187,7 @@ namespace ranges { { return _Zip_tuple_transform( [&_X]( - _IteratorType& _Itr) { return _Itr[_STD iter_difference_t<_IteratorType>{_X}]; }, + _IteratorType& _Itr) -> decltype(auto) { return _Itr[_STD iter_difference_t<_IteratorType>{_X}]; }, _M_Current); } From 2c8a884147b6cacebeb266c304d069c41fff4054 Mon Sep 17 00:00:00 2001 From: Tyler Date: Mon, 15 Aug 2022 16:16:32 -0700 Subject: [PATCH 03/91] Executed a ClangFormat formatting pass. --- stl/inc/ranges | 160 ++++++++++++++++++++++++------------------------- 1 file changed, 80 insertions(+), 80 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 552cdd6ee1e..71cbd50069d 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6840,19 +6840,19 @@ namespace ranges { #ifdef __cpp_lib_ranges_zip template concept _Zip_is_common = (sizeof...(_RangeTypes) == 1 && (_RANGES common_range<_RangeTypes> && ...)) // - || (!(_RANGES bidirectional_range<_RangeTypes> && ...) && (_RANGES common_range<_RangeTypes> && ...)) // - || ((_RANGES random_access_range<_RangeTypes> && ...) && (_RANGES sized_range<_RangeTypes> && ...)); + || (!(_RANGES bidirectional_range<_RangeTypes> && ...) + && (_RANGES common_range<_RangeTypes> && ...)) // + || ((_RANGES random_access_range<_RangeTypes> && ...) + && (_RANGES sized_range<_RangeTypes> && ...)); template - struct _Zip_tuple_or_pair_solver - { + struct _Zip_tuple_or_pair_solver { using _Storage_type = _STD tuple<_RangeTypes...>; }; template requires(sizeof...(_RangeTypes) == 2) - struct _Zip_tuple_or_pair_solver<_RangeTypes...> - { + struct _Zip_tuple_or_pair_solver<_RangeTypes...> { using _Storage_type = _STD pair<_RangeTypes...>; }; @@ -6872,7 +6872,7 @@ namespace ranges { template constexpr auto _Zip_tuple_transform(_CallbackType&& _Callback, _TupleType&& _Tuple) noexcept( noexcept(_STD apply(_Zip_create_tuple_transform_lambda(_STD forward<_CallbackType>(_Callback)), - _STD forward<_TupleType>(_Tuple)))) /* strengthened */ { + _STD forward<_TupleType>(_Tuple)))) /* strengthened */ { return _STD apply(_Zip_create_tuple_transform_lambda(_STD forward<_CallbackType>(_Callback)), _STD forward<_TupleType>(_Tuple)); } @@ -6887,7 +6887,8 @@ namespace ranges { } template - constexpr void _Zip_tuple_for_each(_CallbackType&& _Callback, _TupleType&& _Tuple) noexcept(noexcept(_STD apply(_Zip_create_tuple_for_each_lambda(_STD forward<_CallbackType>(_Callback)), + constexpr void _Zip_tuple_for_each(_CallbackType&& _Callback, _TupleType&& _Tuple) noexcept( + noexcept(_STD apply(_Zip_create_tuple_for_each_lambda(_STD forward<_CallbackType>(_Callback)), _STD forward<_TupleType>(_Tuple)))) /* strengthened */ { _STD apply(_Zip_create_tuple_for_each_lambda(_STD forward<_CallbackType>(_Callback)), _STD forward<_TupleType>(_Tuple)); @@ -6908,7 +6909,7 @@ namespace ranges { template <_RANGES input_range... _ViewTypes> requires _Zip_allow_views<_ViewTypes...> - class zip_view : public _RANGES view_interface> { + class zip_view : public _RANGES view_interface> { public: template class _Iterator; @@ -6942,30 +6943,31 @@ namespace ranges { return _Iterator{_Zip_tuple_transform(_RANGES begin, _M_Views)}; } - _NODISCARD constexpr auto begin() const noexcept( - noexcept(_Zip_tuple_transform(_RANGES begin, _M_Views))) // strengthened + _NODISCARD constexpr auto begin() const + noexcept(noexcept(_Zip_tuple_transform(_RANGES begin, _M_Views))) // strengthened requires(_RANGES range&&...) { return _Iterator{_Zip_tuple_transform(_RANGES begin, _M_Views)}; } - _NODISCARD constexpr auto end() noexcept(noexcept(_Sentinel{ - _Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept(_Iterator{_Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept(_RANGES next(begin(), + _NODISCARD constexpr auto end() noexcept( + noexcept(_Sentinel{_Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept( + _Iterator{_Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept(_RANGES next(begin(), _STD iter_difference_t<_Iterator>{_Get_signed_size()}))) // strengthened requires(!(_Simple_view<_ViewTypes> && ...)) { if constexpr (!_Zip_is_common<_ViewTypes...>) { return _Sentinel{_Zip_tuple_transform(_RANGES end, _M_Views)}; - } - else if constexpr ((_RANGES random_access_range<_ViewTypes> && ...)){ + } else if constexpr ((_RANGES random_access_range<_ViewTypes> && ...)) { return (begin() + _STD iter_difference_t<_Iterator>{_Get_signed_size()}); } else { return _Iterator{_Zip_tuple_transform(_RANGES end, _M_Views)}; } } - _NODISCARD constexpr auto end() const noexcept(noexcept(_Sentinel{ - _Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept(_Iterator{_Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept(_RANGES next(begin(), + _NODISCARD constexpr auto end() const + noexcept(noexcept(_Sentinel{_Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept( + _Iterator{_Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept(_RANGES next(begin(), _STD iter_difference_t<_Iterator>{_Get_signed_size()}))) // strengthened - requires(_RANGES range && ...) { + requires(_RANGES range&&...) { if constexpr (!_Zip_is_common) { return _Sentinel{_Zip_tuple_transform(_RANGES end, _M_Views)}; } else if constexpr ((_RANGES random_access_range && ...)) { @@ -6976,8 +6978,8 @@ namespace ranges { } _NODISCARD constexpr auto size() noexcept(noexcept(_Zip_tuple_for_each(_RANGES size, _M_Views))) // strengthened - requires (_RANGES sized_range<_ViewTypes> && ...) { - using _Common_size_type = _STD common_type_t<_RANGES range_size_t<_ViewTypes>...>; + requires(_RANGES sized_range<_ViewTypes>&&...) { + using _Common_size_type = _STD common_type_t<_RANGES range_size_t<_ViewTypes>...>; using _Common_unsigned_size_type = _Make_unsigned_like_t<_Common_size_type>; auto _Smallest_view_size_value = _STD numeric_limits<_Common_unsigned_size_type>::max(); @@ -6995,8 +6997,9 @@ namespace ranges { return _Smallest_view_size_value; } - _NODISCARD constexpr auto size() const noexcept(noexcept(_Zip_tuple_for_each(_RANGES size, _M_Views))) // strengthened - requires(_RANGES sized_range && ...) { + _NODISCARD constexpr auto size() const + noexcept(noexcept(_Zip_tuple_for_each(_RANGES size, _M_Views))) // strengthened + requires(_RANGES sized_range&&...) { using _Common_size_type = _STD common_type_t<_RANGES range_size_t<_ViewTypes>...>; using _Common_unsigned_size_type = _Make_unsigned_like_t<_Common_size_type>; @@ -7044,22 +7047,20 @@ namespace ranges { zip_view(_RangeTypes&&...) -> zip_view<_RANGES views::all_t<_RangeTypes>...>; template <_RANGES input_range... _RangeTypes> - inline constexpr bool enable_borrowed_range> = - (_RANGES enable_borrowed_range<_RangeTypes> && ...); + inline constexpr bool + enable_borrowed_range> = (_RANGES enable_borrowed_range<_RangeTypes> && ...); template - requires _Zip_allow_views<_ViewTypes...> _NODISCARD constexpr bool _Zip_iterator_sentinel_equality_impl( + requires _Zip_allow_views<_ViewTypes...> _NODISCARD constexpr bool _Zip_iterator_sentinel_equality_impl( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& - _Rhs); + const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs); template - requires _Zip_allow_views<_ViewTypes...> - _NODISCARD constexpr _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...> + requires _Zip_allow_views<_ViewTypes...> _NODISCARD constexpr _STD + common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...> _Zip_get_smallest_iterator_sentinel_distance_impl( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& - _Rhs); + const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs); template <_RANGES input_range... _ViewTypes> requires _Zip_allow_views<_ViewTypes...> @@ -7071,16 +7072,14 @@ namespace ranges { template requires _Zip_allow_views<_Views...> _NODISCARD_FRIEND constexpr bool _Zip_iterator_sentinel_equality_impl( const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& - _Rhs); + const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); template requires _Zip_allow_views<_Views...> _NODISCARD_FRIEND constexpr _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _Views>>...> _Zip_get_smallest_iterator_sentinel_distance_impl( const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& - _Rhs); + const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); using _Iterator_tuple_type = _Zip_tuple_or_pair<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>...>; @@ -7107,7 +7106,7 @@ namespace ranges { _STD conditional_t<_Zip_all_forward<_IsConst, _ViewTypes...>, _STD forward_iterator_tag, _STD input_iterator_tag>>>; - using value_type = _Zip_tuple_or_pair<_RANGES range_value_t<_Maybe_const<_IsConst, _ViewTypes>>...>; + using value_type = _Zip_tuple_or_pair<_RANGES range_value_t<_Maybe_const<_IsConst, _ViewTypes>>...>; using difference_type = _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IsConst, _ViewTypes>>...>; _Iterator() noexcept(_STD is_nothrow_default_constructible_v<_Iterator_tuple_type>) = default; @@ -7133,7 +7132,8 @@ namespace ranges { ++(*this); } - constexpr _Iterator operator++(int) noexcept(_Is_nothrow_preincrementable && _STD is_nothrow_copy_assignable_v<_Iterator<_IsConst>>) // strengthened + constexpr _Iterator operator++(int) noexcept( + _Is_nothrow_preincrementable&& _STD is_nothrow_copy_assignable_v<_Iterator<_IsConst>>) // strengthened requires _Zip_all_forward<_IsConst, _ViewTypes...> { const auto _Temp = *this; ++(*this); @@ -7147,7 +7147,8 @@ namespace ranges { return *this; } - constexpr _Iterator operator--(int) noexcept(_Is_nothrow_predecrementable && _STD is_nothrow_copy_assignable_v<_Iterator<_IsConst>>) // strengthened + constexpr _Iterator operator--(int) noexcept( + _Is_nothrow_predecrementable&& _STD is_nothrow_copy_assignable_v<_Iterator<_IsConst>>) // strengthened requires _Zip_all_bidirectional<_IsConst, _ViewTypes...> { const auto _Temp = *this; --(*this); @@ -7169,7 +7170,7 @@ namespace ranges { constexpr _Iterator& operator-=(difference_type _X) noexcept( (noexcept(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>() -= - _STD iter_difference_t<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>{_X}) + _STD iter_difference_t<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>{_X}) && ...)) // strengthened requires _Zip_all_random_access<_IsConst, _ViewTypes...> { _Zip_tuple_for_each([&_X]( @@ -7179,22 +7180,20 @@ namespace ranges { return *this; } - _NODISCARD constexpr auto operator[](difference_type _X) const noexcept( - (noexcept((_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())[_STD - iter_difference_t<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>{_X}]) - && ...)) // strengthened - requires _Zip_all_random_access<_IsConst, _ViewTypes...> - { + _NODISCARD constexpr auto operator[](difference_type _X) const + noexcept((noexcept((_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())[_STD + iter_difference_t<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>{_X}]) + && ...)) // strengthened + requires _Zip_all_random_access<_IsConst, _ViewTypes...> { return _Zip_tuple_transform( [&_X]( _IteratorType& _Itr) -> decltype(auto) { return _Itr[_STD iter_difference_t<_IteratorType>{_X}]; }, _M_Current); } - _NODISCARD_FRIEND constexpr bool operator==( - const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept(noexcept(_Lhs._M_Current == _Rhs._M_Current)) // strengthened - requires (_STD equality_comparable<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...) - { + _NODISCARD_FRIEND constexpr bool operator==(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( + noexcept(_Lhs._M_Current == _Rhs._M_Current)) // strengthened + requires(_STD equality_comparable<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { if constexpr (_Zip_all_bidirectional<_IsConst, _ViewTypes...>) { return (_Lhs._M_Current == _Rhs._M_Current); } else { @@ -7214,15 +7213,15 @@ namespace ranges { } } - _NODISCARD_FRIEND constexpr auto operator<=>(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept(noexcept(_Lhs._M_Current <=> _Rhs._M_Current)) // strengthened + _NODISCARD_FRIEND constexpr auto operator<=>(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( + noexcept(_Lhs._M_Current <=> _Rhs._M_Current)) // strengthened requires _Zip_all_random_access<_IsConst, _ViewTypes...> { return (_Lhs._M_Current <=> _Rhs._M_Current); } _NODISCARD_FRIEND constexpr _Iterator operator+(const _Iterator& _Lhs, difference_type _Rhs) noexcept( noexcept(_STD declval<_Iterator>() += _Rhs) && _STD is_nothrow_copy_assignable_v<_Iterator>) // strengthened - requires _Zip_all_random_access<_IsConst, _ViewTypes...> - { + requires _Zip_all_random_access<_IsConst, _ViewTypes...> { auto _Modified_iterator = _Lhs; _Modified_iterator += _Rhs; @@ -7236,8 +7235,7 @@ namespace ranges { _NODISCARD_FRIEND constexpr _Iterator operator-(const _Iterator& _Lhs, difference_type _Rhs) noexcept( noexcept(_STD declval<_Iterator>() -= _Rhs) && _STD is_nothrow_copy_assignable_v<_Iterator>) // strengthened - requires _Zip_all_random_access<_IsConst, _ViewTypes...> - { + requires _Zip_all_random_access<_IsConst, _ViewTypes...> { auto _Modified_iterator = _Lhs; _Modified_iterator -= _Rhs; @@ -7245,10 +7243,13 @@ namespace ranges { } _NODISCARD_FRIEND constexpr difference_type operator-(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( - (noexcept(difference_type{_RANGES distance(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), - _STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())}) && ...) && noexcept(_STD declval() < _STD declval()) && _STD is_nothrow_copy_assignable_v) // strengthened - requires(_STD sized_sentinel_for<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>, - _RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...) { + (noexcept(difference_type{ + _RANGES distance(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), + _STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())}) + && ...) && noexcept(_STD declval() < _STD declval()) + && _STD is_nothrow_copy_assignable_v) // strengthened + requires(_STD sized_sentinel_for<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>, + _RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { if constexpr (sizeof...(_ViewTypes) == 1) { return difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_Current)}; } else { @@ -7291,10 +7292,10 @@ namespace ranges { return _Zip_tuple_transform(_RANGES iter_move, _Itr._M_Current); } - friend constexpr void iter_swap(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( - (noexcept(_RANGES iter_swap(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), - _STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())) - && ...)) requires(_STD indirectly_swappable<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...) { + friend constexpr void iter_swap(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept(( + noexcept(_RANGES iter_swap(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), + _STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())) + && ...)) requires(_STD indirectly_swappable<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { const auto _Perform_swap_lambda = [&_Lhs, &_Rhs]<_STD size_t _CurrIndex>(this const auto& self) { if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { _RANGES iter_swap(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_Current)); @@ -7321,16 +7322,14 @@ namespace ranges { template requires _Zip_allow_views<_Views...> _NODISCARD_FRIEND constexpr bool _Zip_iterator_sentinel_equality_impl( const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& - _Rhs); + const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); template requires _Zip_allow_views<_Views...> _NODISCARD_FRIEND constexpr _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _Views>>...> _Zip_get_smallest_iterator_sentinel_distance_impl( const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& - _Rhs); + const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); using _Sentinel_tuple_type = _Zip_tuple_or_pair<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>...>; @@ -7339,7 +7338,8 @@ namespace ranges { : _M_End(_End) {} template - using _Iterator_sentinel_difference_type = _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>; + using _Iterator_sentinel_difference_type = + _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>; template static constexpr bool _Zip_iterator_sentinel_equality_noexcept = @@ -7362,24 +7362,26 @@ namespace ranges { public: _Sentinel() noexcept(_STD is_nothrow_default_constructible_v<_Sentinel_tuple_type>) = default; - constexpr _Sentinel(_Sentinel _Rhs) noexcept(_STD is_nothrow_move_constructible_v<_Sentinel_tuple_type>) // strengthened + constexpr _Sentinel(_Sentinel _Rhs) noexcept( + _STD is_nothrow_move_constructible_v<_Sentinel_tuple_type>) // strengthened requires(_IsConst && (_STD convertible_to<_RANGES sentinel_t<_ViewTypes>, _RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) : _M_End(_STD move(_Rhs._M_End)) {} template - requires(_STD sentinel_for<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>, _RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>> && ...) + requires(_STD sentinel_for<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>, + _RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) _NODISCARD_FRIEND constexpr bool operator==( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const _Sentinel& _Rhs) noexcept(_Zip_iterator_sentinel_equality_noexcept<_IsConst, - _IteratorConst, _ViewTypes...>) /* strengthened */ { + const _Sentinel& _Rhs) noexcept(_Zip_iterator_sentinel_equality_noexcept<_IsConst, _IteratorConst, + _ViewTypes...>) /* strengthened */ { return _Zip_iterator_sentinel_equality_impl<_IsConst, _IteratorConst, _ViewTypes...>(_Lhs, _Rhs); } template - requires (_STD sized_sentinel_for<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>, - _RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>> && ...) + requires(_STD sized_sentinel_for<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>, + _RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) _NODISCARD_FRIEND constexpr _Iterator_sentinel_difference_type<_IteratorConst> operator-( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, const _Sentinel& _Rhs) noexcept(_Zip_get_smallest_iterator_sentinel_distance_noexcept<_IsConst, @@ -7390,7 +7392,7 @@ namespace ranges { template requires(_STD sized_sentinel_for<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>, - _RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>> && ...) + _RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) _NODISCARD_FRIEND constexpr _Iterator_sentinel_difference_type<_IteratorConst> operator-(const _Sentinel& _Lhs, const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Rhs) noexcept(noexcept(-(_Rhs - _Lhs))) /* strengthened */ { @@ -7404,8 +7406,7 @@ namespace ranges { template requires _Zip_allow_views<_ViewTypes...> _NODISCARD constexpr bool _Zip_iterator_sentinel_equality_impl( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& - _Rhs) { + const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs) { const auto _Evaluate_tuple_values_lambda = [&_Lhs, &_Rhs]<_STD size_t _CurrIndex>(this const auto& self) { if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { if (_STD get<_CurrIndex>(_Lhs._M_Current) == _STD get<_CurrIndex>(_Rhs._M_End)) @@ -7426,8 +7427,7 @@ namespace ranges { common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...> _Zip_get_smallest_iterator_sentinel_distance_impl( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& - _Rhs) { + const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs) { using _Difference_type = _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>; @@ -7462,13 +7462,13 @@ namespace ranges { } namespace views { - class _Zip_function{ + class _Zip_function { public: _Zip_function() noexcept = default; template <_RANGES input_range... _ViewTypes> constexpr auto operator()(_ViewTypes&&... _Views) const noexcept(noexcept( - _RANGES views::empty<_STD tuple<>>) && noexcept(zip_view{ _STD forward<_ViewTypes>(_Views)... })) { + _RANGES views::empty<_STD tuple<>>) && noexcept(zip_view{_STD forward<_ViewTypes>(_Views)...})) { if constexpr (sizeof...(_ViewTypes) == 0) { return _RANGES views::empty<_STD tuple<>>; } else { From c3eb3586fe9da71c8273aa8bd575399dd0b0785e Mon Sep 17 00:00:00 2001 From: Tyler Date: Mon, 15 Aug 2022 16:51:34 -0700 Subject: [PATCH 04/91] Moved most implementation details into a different namespace. --- stl/inc/ranges | 356 +++++++++++++++++++++++++------------------------ 1 file changed, 182 insertions(+), 174 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 71cbd50069d..155424b9bb7 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6838,77 +6838,79 @@ namespace ranges { } // namespace views #ifdef __cpp_lib_ranges_zip - template - concept _Zip_is_common = (sizeof...(_RangeTypes) == 1 && (_RANGES common_range<_RangeTypes> && ...)) // + namespace _Zip { + template + concept _Is_common = (sizeof...(_RangeTypes) == 1 && (_RANGES common_range<_RangeTypes> && ...)) // || (!(_RANGES bidirectional_range<_RangeTypes> && ...) && (_RANGES common_range<_RangeTypes> && ...)) // || ((_RANGES random_access_range<_RangeTypes> && ...) && (_RANGES sized_range<_RangeTypes> && ...)); - template - struct _Zip_tuple_or_pair_solver { - using _Storage_type = _STD tuple<_RangeTypes...>; - }; + template + struct _Tuple_or_pair_solver { + using _Storage_type = _STD tuple<_RangeTypes...>; + }; - template - requires(sizeof...(_RangeTypes) == 2) - struct _Zip_tuple_or_pair_solver<_RangeTypes...> { - using _Storage_type = _STD pair<_RangeTypes...>; - }; + template + requires(sizeof...(_RangeTypes) == 2) + struct _Tuple_or_pair_solver<_RangeTypes...> { + using _Storage_type = _STD pair<_RangeTypes...>; + }; - template - using _Zip_tuple_or_pair = typename _Zip_tuple_or_pair_solver<_RangeTypes...>::_Storage_type; + template + using _Tuple_or_pair = typename _Tuple_or_pair_solver<_RangeTypes...>::_Storage_type; - template - constexpr auto _Zip_create_tuple_transform_lambda(_CallbackType&& _Callback) noexcept { - const auto _Created_lambda = [&_Callback](_ViewTupleTypes&&... _View_tuples) { - return _Zip_tuple_or_pair<_STD invoke_result_t<_CallbackType&, _ViewTupleTypes>...>{ - _STD invoke(_Callback, _STD forward<_ViewTupleTypes>(_View_tuples))...}; - }; + template + constexpr auto _Create_tuple_transform_lambda(_CallbackType&& _Callback) noexcept { + const auto _Created_lambda = [&_Callback](_ViewTupleTypes&&... _View_tuples) { + return _Zip::_Tuple_or_pair<_STD invoke_result_t<_CallbackType&, _ViewTupleTypes>...>{ + _STD invoke(_Callback, _STD forward<_ViewTupleTypes>(_View_tuples))...}; + }; - return _Created_lambda; - } + return _Created_lambda; + } - template - constexpr auto _Zip_tuple_transform(_CallbackType&& _Callback, _TupleType&& _Tuple) noexcept( - noexcept(_STD apply(_Zip_create_tuple_transform_lambda(_STD forward<_CallbackType>(_Callback)), - _STD forward<_TupleType>(_Tuple)))) /* strengthened */ { - return _STD apply(_Zip_create_tuple_transform_lambda(_STD forward<_CallbackType>(_Callback)), - _STD forward<_TupleType>(_Tuple)); - } + template + constexpr auto _Tuple_transform(_CallbackType&& _Callback, _TupleType&& _Tuple) noexcept( + noexcept(_STD apply(_Zip::_Create_tuple_transform_lambda(_STD forward<_CallbackType>(_Callback)), + _STD forward<_TupleType>(_Tuple)))) /* strengthened */ { + return _STD apply(_Zip::_Create_tuple_transform_lambda(_STD forward<_CallbackType>(_Callback)), + _STD forward<_TupleType>(_Tuple)); + } - template - constexpr auto _Zip_create_tuple_for_each_lambda(_CallbackType&& _Callback) noexcept { - const auto _Created_lambda = [&_Callback](_ViewTupleTypes&&... _View_tuples) { - (_STD invoke(_Callback, _STD forward<_ViewTupleTypes>(_View_tuples)), ...); - }; + template + constexpr auto _Create_tuple_for_each_lambda(_CallbackType&& _Callback) noexcept { + const auto _Created_lambda = [&_Callback](_ViewTupleTypes&&... _View_tuples) { + (_STD invoke(_Callback, _STD forward<_ViewTupleTypes>(_View_tuples)), ...); + }; - return _Created_lambda; - } + return _Created_lambda; + } - template - constexpr void _Zip_tuple_for_each(_CallbackType&& _Callback, _TupleType&& _Tuple) noexcept( - noexcept(_STD apply(_Zip_create_tuple_for_each_lambda(_STD forward<_CallbackType>(_Callback)), - _STD forward<_TupleType>(_Tuple)))) /* strengthened */ { - _STD apply(_Zip_create_tuple_for_each_lambda(_STD forward<_CallbackType>(_Callback)), - _STD forward<_TupleType>(_Tuple)); - } + template + constexpr void _Tuple_for_each(_CallbackType&& _Callback, _TupleType&& _Tuple) noexcept( + noexcept(_STD apply(_Zip::_Create_tuple_for_each_lambda(_STD forward<_CallbackType>(_Callback)), + _STD forward<_TupleType>(_Tuple)))) /* strengthened */ { + _STD apply(_Zip::_Create_tuple_for_each_lambda(_STD forward<_CallbackType>(_Callback)), + _STD forward<_TupleType>(_Tuple)); + } - template - concept _Zip_all_random_access = (_RANGES random_access_range<_Maybe_const<_IsConst, _Views>> && ...); + template + concept _All_random_access = (_RANGES random_access_range<_Maybe_const<_IsConst, _Views>> && ...); - template - concept _Zip_all_bidirectional = (_RANGES bidirectional_range<_Maybe_const<_IsConst, _Views>> && ...); + template + concept _All_bidirectional = (_RANGES bidirectional_range<_Maybe_const<_IsConst, _Views>> && ...); - template - concept _Zip_all_forward = (_RANGES forward_range<_Maybe_const<_IsConst, _Views>> && ...); + template + concept _All_forward = (_RANGES forward_range<_Maybe_const<_IsConst, _Views>> && ...); - template - concept _Zip_allow_views = (_RANGES input_range<_ViewTypes> && ...) && (_RANGES view<_ViewTypes> && ...) + template + concept _Allow_views = (_RANGES input_range<_ViewTypes> && ...) && (_RANGES view<_ViewTypes> && ...) && (sizeof...(_ViewTypes) > 0); + } // namespace _Zip template <_RANGES input_range... _ViewTypes> - requires _Zip_allow_views<_ViewTypes...> + requires _Zip::_Allow_views<_ViewTypes...> class zip_view : public _RANGES view_interface> { public: template @@ -6925,7 +6927,7 @@ namespace ranges { struct _Iterator_category_container {}; template - requires _Zip_all_forward<_IsConst, _ViewTypes...> + requires _Zip::_All_forward<_IsConst, _ViewTypes...> struct _Iterator_category_container<_Iterator<_IsConst>> { using iterator_category = _STD input_iterator_tag; }; @@ -6938,53 +6940,54 @@ namespace ranges { : _M_Views(_STD move(_Views)...) {} _NODISCARD constexpr auto begin() noexcept( - noexcept(_Zip_tuple_transform(_RANGES begin, _M_Views))) // strengthened + noexcept(_Zip::_Tuple_transform(_RANGES begin, _M_Views))) // strengthened requires(!(_Simple_view<_ViewTypes> && ...)) { - return _Iterator{_Zip_tuple_transform(_RANGES begin, _M_Views)}; + return _Iterator{_Zip::_Tuple_transform(_RANGES begin, _M_Views)}; } _NODISCARD constexpr auto begin() const - noexcept(noexcept(_Zip_tuple_transform(_RANGES begin, _M_Views))) // strengthened + noexcept(noexcept(_Zip::_Tuple_transform(_RANGES begin, _M_Views))) // strengthened requires(_RANGES range&&...) { - return _Iterator{_Zip_tuple_transform(_RANGES begin, _M_Views)}; + return _Iterator{_Zip::_Tuple_transform(_RANGES begin, _M_Views)}; } _NODISCARD constexpr auto end() noexcept( - noexcept(_Sentinel{_Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept( - _Iterator{_Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept(_RANGES next(begin(), + noexcept(_Sentinel{_Zip::_Tuple_transform(_RANGES end, _M_Views)}) && noexcept( + _Iterator{_Zip::_Tuple_transform(_RANGES end, _M_Views)}) && noexcept(_RANGES next(begin(), _STD iter_difference_t<_Iterator>{_Get_signed_size()}))) // strengthened requires(!(_Simple_view<_ViewTypes> && ...)) { - if constexpr (!_Zip_is_common<_ViewTypes...>) { - return _Sentinel{_Zip_tuple_transform(_RANGES end, _M_Views)}; + if constexpr (!_Zip::_Is_common<_ViewTypes...>) { + return _Sentinel{_Zip::_Tuple_transform(_RANGES end, _M_Views)}; } else if constexpr ((_RANGES random_access_range<_ViewTypes> && ...)) { - return (begin() + _STD iter_difference_t<_Iterator>{_Get_signed_size()}); + return _RANGES next(begin(), _STD iter_difference_t<_Iterator>{_Get_signed_size()}); } else { - return _Iterator{_Zip_tuple_transform(_RANGES end, _M_Views)}; + return _Iterator{_Zip::_Tuple_transform(_RANGES end, _M_Views)}; } } _NODISCARD constexpr auto end() const - noexcept(noexcept(_Sentinel{_Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept( - _Iterator{_Zip_tuple_transform(_RANGES end, _M_Views)}) && noexcept(_RANGES next(begin(), + noexcept(noexcept(_Sentinel{_Zip::_Tuple_transform(_RANGES end, _M_Views)}) && noexcept( + _Iterator{_Zip::_Tuple_transform(_RANGES end, _M_Views)}) && noexcept(_RANGES next(begin(), _STD iter_difference_t<_Iterator>{_Get_signed_size()}))) // strengthened requires(_RANGES range&&...) { - if constexpr (!_Zip_is_common) { - return _Sentinel{_Zip_tuple_transform(_RANGES end, _M_Views)}; + if constexpr (!_Zip::_Is_common) { + return _Sentinel{_Zip::_Tuple_transform(_RANGES end, _M_Views)}; } else if constexpr ((_RANGES random_access_range && ...)) { - return (begin() + _STD iter_difference_t<_Iterator>{_Get_signed_size()}); + return _RANGES next(begin(), _STD iter_difference_t<_Iterator>{_Get_signed_size()}); } else { - return _Iterator{_Zip_tuple_transform(_RANGES end, _M_Views)}; + return _Iterator{_Zip::_Tuple_transform(_RANGES end, _M_Views)}; } } - _NODISCARD constexpr auto size() noexcept(noexcept(_Zip_tuple_for_each(_RANGES size, _M_Views))) // strengthened + _NODISCARD constexpr auto size() noexcept( + noexcept(_Zip::_Tuple_for_each(_RANGES size, _M_Views))) // strengthened requires(_RANGES sized_range<_ViewTypes>&&...) { using _Common_size_type = _STD common_type_t<_RANGES range_size_t<_ViewTypes>...>; using _Common_unsigned_size_type = _Make_unsigned_like_t<_Common_size_type>; auto _Smallest_view_size_value = _STD numeric_limits<_Common_unsigned_size_type>::max(); - _Zip_tuple_for_each( + _Zip::_Tuple_for_each( [&_Smallest_view_size_value](_View& _Curr_view) { const auto _Curr_view_size_value = static_cast<_Common_unsigned_size_type>(_RANGES size(_Curr_view)); @@ -6998,14 +7001,14 @@ namespace ranges { } _NODISCARD constexpr auto size() const - noexcept(noexcept(_Zip_tuple_for_each(_RANGES size, _M_Views))) // strengthened + noexcept(noexcept(_Zip::_Tuple_for_each(_RANGES size, _M_Views))) // strengthened requires(_RANGES sized_range&&...) { using _Common_size_type = _STD common_type_t<_RANGES range_size_t<_ViewTypes>...>; using _Common_unsigned_size_type = _Make_unsigned_like_t<_Common_size_type>; auto _Smallest_view_size_value = _STD numeric_limits<_Common_unsigned_size_type>::max(); - _Zip_tuple_for_each( + _Zip::_Tuple_for_each( [&_Smallest_view_size_value](const _View& _Curr_view) { const auto _Curr_view_size_value = static_cast<_Common_unsigned_size_type>(_RANGES size(_Curr_view)); @@ -7040,7 +7043,7 @@ namespace ranges { } private: - _Zip_tuple_or_pair<_ViewTypes...> _M_Views; + _Zip::_Tuple_or_pair<_ViewTypes...> _M_Views; }; template @@ -7050,38 +7053,40 @@ namespace ranges { inline constexpr bool enable_borrowed_range> = (_RANGES enable_borrowed_range<_RangeTypes> && ...); - template - requires _Zip_allow_views<_ViewTypes...> _NODISCARD constexpr bool _Zip_iterator_sentinel_equality_impl( - const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs); - - template - requires _Zip_allow_views<_ViewTypes...> _NODISCARD constexpr _STD - common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...> - _Zip_get_smallest_iterator_sentinel_distance_impl( + namespace _Zip { + template + requires _Zip::_Allow_views<_ViewTypes...> _NODISCARD constexpr bool _Iterator_sentinel_equality_impl( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs); + template + requires _Zip::_Allow_views<_ViewTypes...> _NODISCARD constexpr _STD + common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...> + _Get_smallest_iterator_sentinel_distance_impl( + const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, + const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs); + } // namespace _Zip + template <_RANGES input_range... _ViewTypes> - requires _Zip_allow_views<_ViewTypes...> + requires _Zip::_Allow_views<_ViewTypes...> template class zip_view<_ViewTypes...>::_Iterator : public _Iterator_category_container<_Iterator<_IsConst>> { private: friend class zip_view<_ViewTypes...>; template - requires _Zip_allow_views<_Views...> _NODISCARD_FRIEND constexpr bool _Zip_iterator_sentinel_equality_impl( + requires _Zip::_Allow_views<_Views...> _NODISCARD_FRIEND constexpr bool _Zip::_Iterator_sentinel_equality_impl( const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); template - requires _Zip_allow_views<_Views...> _NODISCARD_FRIEND constexpr _STD + requires _Zip::_Allow_views<_Views...> _NODISCARD_FRIEND constexpr _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _Views>>...> - _Zip_get_smallest_iterator_sentinel_distance_impl( + _Zip::_Get_smallest_iterator_sentinel_distance_impl( const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); - using _Iterator_tuple_type = _Zip_tuple_or_pair<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>...>; + using _Iterator_tuple_type = _Zip::_Tuple_or_pair<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>...>; constexpr explicit _Iterator(_Iterator_tuple_type _Current) noexcept( _STD is_nothrow_move_constructible_v<_Iterator_tuple_type>) @@ -7101,12 +7106,12 @@ namespace ranges { // a type alias in _Iterator_category_container. using iterator_concept = - _STD conditional_t<_Zip_all_random_access<_IsConst, _ViewTypes...>, _STD random_access_iterator_tag, - _STD conditional_t<_Zip_all_bidirectional<_IsConst, _ViewTypes...>, _STD bidirectional_iterator_tag, - _STD conditional_t<_Zip_all_forward<_IsConst, _ViewTypes...>, _STD forward_iterator_tag, + _STD conditional_t<_Zip::_All_random_access<_IsConst, _ViewTypes...>, _STD random_access_iterator_tag, + _STD conditional_t<_Zip::_All_bidirectional<_IsConst, _ViewTypes...>, _STD bidirectional_iterator_tag, + _STD conditional_t<_Zip::_All_forward<_IsConst, _ViewTypes...>, _STD forward_iterator_tag, _STD input_iterator_tag>>>; - using value_type = _Zip_tuple_or_pair<_RANGES range_value_t<_Maybe_const<_IsConst, _ViewTypes>>...>; + using value_type = _Zip::_Tuple_or_pair<_RANGES range_value_t<_Maybe_const<_IsConst, _ViewTypes>>...>; using difference_type = _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IsConst, _ViewTypes>>...>; _Iterator() noexcept(_STD is_nothrow_default_constructible_v<_Iterator_tuple_type>) = default; @@ -7120,11 +7125,11 @@ namespace ranges { : _M_Current(_STD move(_Rhs._M_Current)) {} _NODISCARD constexpr auto operator*() const noexcept(_Is_nothrow_dereferenceable) /* strengthened */ { - return _Zip_tuple_transform([](auto& _Itr) -> decltype(auto) { return *_Itr; }, _M_Current); + return _Zip::_Tuple_transform([](auto& _Itr) -> decltype(auto) { return *_Itr; }, _M_Current); } constexpr _Iterator& operator++() noexcept(_Is_nothrow_preincrementable) /* strengthened */ { - _Zip_tuple_for_each([](auto& _Itr) { ++_Itr; }, _M_Current); + _Zip::_Tuple_for_each([](auto& _Itr) { ++_Itr; }, _M_Current); return *this; } @@ -7134,7 +7139,7 @@ namespace ranges { constexpr _Iterator operator++(int) noexcept( _Is_nothrow_preincrementable&& _STD is_nothrow_copy_assignable_v<_Iterator<_IsConst>>) // strengthened - requires _Zip_all_forward<_IsConst, _ViewTypes...> { + requires _Zip::_All_forward<_IsConst, _ViewTypes...> { const auto _Temp = *this; ++(*this); @@ -7142,14 +7147,14 @@ namespace ranges { } constexpr _Iterator& operator--() noexcept(_Is_nothrow_predecrementable) // strengthened - requires _Zip_all_bidirectional<_IsConst, _ViewTypes...> { - _Zip_tuple_for_each([](auto& _Itr) { --_Itr; }, _M_Current); + requires _Zip::_All_bidirectional<_IsConst, _ViewTypes...> { + _Zip::_Tuple_for_each([](auto& _Itr) { --_Itr; }, _M_Current); return *this; } constexpr _Iterator operator--(int) noexcept( _Is_nothrow_predecrementable&& _STD is_nothrow_copy_assignable_v<_Iterator<_IsConst>>) // strengthened - requires _Zip_all_bidirectional<_IsConst, _ViewTypes...> { + requires _Zip::_All_bidirectional<_IsConst, _ViewTypes...> { const auto _Temp = *this; --(*this); @@ -7160,9 +7165,9 @@ namespace ranges { (noexcept(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>() += _STD iter_difference_t<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>{_X}) && ...)) // strengthened - requires _Zip_all_random_access<_IsConst, _ViewTypes...> { - _Zip_tuple_for_each([&_X]( - _IteratorType& _Itr) { _Itr += _STD iter_difference_t<_IteratorType>{_X}; }, + requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { + _Zip::_Tuple_for_each([&_X]( + _IteratorType& _Itr) { _Itr += _STD iter_difference_t<_IteratorType>{_X}; }, _M_Current); return *this; @@ -7172,9 +7177,9 @@ namespace ranges { (noexcept(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>() -= _STD iter_difference_t<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>{_X}) && ...)) // strengthened - requires _Zip_all_random_access<_IsConst, _ViewTypes...> { - _Zip_tuple_for_each([&_X]( - _IteratorType& _Itr) { _Itr -= _STD iter_difference_t<_IteratorType>{_X}; }, + requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { + _Zip::_Tuple_for_each([&_X]( + _IteratorType& _Itr) { _Itr -= _STD iter_difference_t<_IteratorType>{_X}; }, _M_Current); return *this; @@ -7184,8 +7189,8 @@ namespace ranges { noexcept((noexcept((_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())[_STD iter_difference_t<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>{_X}]) && ...)) // strengthened - requires _Zip_all_random_access<_IsConst, _ViewTypes...> { - return _Zip_tuple_transform( + requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { + return _Zip::_Tuple_transform( [&_X]( _IteratorType& _Itr) -> decltype(auto) { return _Itr[_STD iter_difference_t<_IteratorType>{_X}]; }, _M_Current); @@ -7194,7 +7199,7 @@ namespace ranges { _NODISCARD_FRIEND constexpr bool operator==(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( noexcept(_Lhs._M_Current == _Rhs._M_Current)) // strengthened requires(_STD equality_comparable<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { - if constexpr (_Zip_all_bidirectional<_IsConst, _ViewTypes...>) { + if constexpr (_Zip::_All_bidirectional<_IsConst, _ViewTypes...>) { return (_Lhs._M_Current == _Rhs._M_Current); } else { const auto _Compare_elements_lambda = [&_Lhs, &_Rhs]<_STD size_t _CurrIndex>(this const auto& self) { @@ -7215,13 +7220,13 @@ namespace ranges { _NODISCARD_FRIEND constexpr auto operator<=>(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( noexcept(_Lhs._M_Current <=> _Rhs._M_Current)) // strengthened - requires _Zip_all_random_access<_IsConst, _ViewTypes...> { + requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { return (_Lhs._M_Current <=> _Rhs._M_Current); } _NODISCARD_FRIEND constexpr _Iterator operator+(const _Iterator& _Lhs, difference_type _Rhs) noexcept( noexcept(_STD declval<_Iterator>() += _Rhs) && _STD is_nothrow_copy_assignable_v<_Iterator>) // strengthened - requires _Zip_all_random_access<_IsConst, _ViewTypes...> { + requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { auto _Modified_iterator = _Lhs; _Modified_iterator += _Rhs; @@ -7229,13 +7234,13 @@ namespace ranges { } _NODISCARD_FRIEND constexpr _Iterator operator+(difference_type _Lhs, const _Iterator& _Rhs) noexcept( - noexcept(_Rhs + _Lhs)) /* strengthened */ requires _Zip_all_random_access<_IsConst, _ViewTypes...> { + noexcept(_Rhs + _Lhs)) /* strengthened */ requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { return (_Rhs + _Lhs); } _NODISCARD_FRIEND constexpr _Iterator operator-(const _Iterator& _Lhs, difference_type _Rhs) noexcept( noexcept(_STD declval<_Iterator>() -= _Rhs) && _STD is_nothrow_copy_assignable_v<_Iterator>) // strengthened - requires _Zip_all_random_access<_IsConst, _ViewTypes...> { + requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { auto _Modified_iterator = _Lhs; _Modified_iterator -= _Rhs; @@ -7289,7 +7294,7 @@ namespace ranges { && ...) && (_STD is_nothrow_move_constructible_v< _RANGES range_rvalue_reference_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) { - return _Zip_tuple_transform(_RANGES iter_move, _Itr._M_Current); + return _Zip::_Tuple_transform(_RANGES iter_move, _Itr._M_Current); } friend constexpr void iter_swap(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept(( @@ -7313,25 +7318,25 @@ namespace ranges { }; template <_RANGES input_range... _ViewTypes> - requires _Zip_allow_views<_ViewTypes...> + requires _Zip::_Allow_views<_ViewTypes...> template class zip_view<_ViewTypes...>::_Sentinel { private: friend class zip_view<_ViewTypes...>; template - requires _Zip_allow_views<_Views...> _NODISCARD_FRIEND constexpr bool _Zip_iterator_sentinel_equality_impl( + requires _Zip::_Allow_views<_Views...> _NODISCARD_FRIEND constexpr bool _Zip::_Iterator_sentinel_equality_impl( const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); template - requires _Zip_allow_views<_Views...> _NODISCARD_FRIEND constexpr _STD + requires _Zip::_Allow_views<_Views...> _NODISCARD_FRIEND constexpr _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _Views>>...> - _Zip_get_smallest_iterator_sentinel_distance_impl( + _Zip::_Get_smallest_iterator_sentinel_distance_impl( const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); - using _Sentinel_tuple_type = _Zip_tuple_or_pair<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>...>; + using _Sentinel_tuple_type = _Zip::_Tuple_or_pair<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>...>; constexpr explicit _Sentinel(_Sentinel_tuple_type _End) noexcept( _STD is_nothrow_copy_assignable_v<_Sentinel_tuple_type>) // strengthened @@ -7342,13 +7347,13 @@ namespace ranges { _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>; template - static constexpr bool _Zip_iterator_sentinel_equality_noexcept = + static constexpr bool _Iterator_sentinel_equality_noexcept = (noexcept(_STD declval<_RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>() == _STD declval<_RANGES sentinel_t<_Maybe_const<_SentinelConst, _ViewTypes>>>()) && ...); template - static constexpr bool _Zip_get_smallest_iterator_sentinel_distance_noexcept = + static constexpr bool _Get_smallest_iterator_sentinel_distance_noexcept = (noexcept(_STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>{ _RANGES distance(_STD declval<_RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>(), _STD declval<_RANGES sentinel_t<_Maybe_const<_SentinelConst, _ViewTypes>>>())}) @@ -7374,9 +7379,9 @@ namespace ranges { _RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) _NODISCARD_FRIEND constexpr bool operator==( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const _Sentinel& _Rhs) noexcept(_Zip_iterator_sentinel_equality_noexcept<_IsConst, _IteratorConst, + const _Sentinel& _Rhs) noexcept(_Iterator_sentinel_equality_noexcept<_IsConst, _IteratorConst, _ViewTypes...>) /* strengthened */ { - return _Zip_iterator_sentinel_equality_impl<_IsConst, _IteratorConst, _ViewTypes...>(_Lhs, _Rhs); + return _Zip::_Iterator_sentinel_equality_impl<_IsConst, _IteratorConst, _ViewTypes...>(_Lhs, _Rhs); } template @@ -7384,9 +7389,9 @@ namespace ranges { _RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) _NODISCARD_FRIEND constexpr _Iterator_sentinel_difference_type<_IteratorConst> operator-( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const _Sentinel& _Rhs) noexcept(_Zip_get_smallest_iterator_sentinel_distance_noexcept<_IsConst, - _IteratorConst, _ViewTypes...>) /* strengthened */ { - return _Zip_get_smallest_iterator_sentinel_distance_impl<_IsConst, _IteratorConst, _ViewTypes...>( + const _Sentinel& _Rhs) noexcept(_Get_smallest_iterator_sentinel_distance_noexcept<_IsConst, _IteratorConst, + _ViewTypes...>) /* strengthened */ { + return _Zip::_Get_smallest_iterator_sentinel_distance_impl<_IsConst, _IteratorConst, _ViewTypes...>( _Lhs, _Rhs); } @@ -7403,65 +7408,66 @@ namespace ranges { _Sentinel_tuple_type _M_End; }; - template - requires _Zip_allow_views<_ViewTypes...> _NODISCARD constexpr bool _Zip_iterator_sentinel_equality_impl( - const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs) { - const auto _Evaluate_tuple_values_lambda = [&_Lhs, &_Rhs]<_STD size_t _CurrIndex>(this const auto& self) { - if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { - if (_STD get<_CurrIndex>(_Lhs._M_Current) == _STD get<_CurrIndex>(_Rhs._M_End)) - return true; - - static constexpr auto _Next_index = (_CurrIndex + 1); - return self.operator()<_Next_index>(); - } else { - return false; - } - }; - - return _Evaluate_tuple_values_lambda.operator()<0>(); - } - - template - requires _Zip_allow_views<_ViewTypes...> _NODISCARD constexpr _STD - common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...> - _Zip_get_smallest_iterator_sentinel_distance_impl( + namespace _Zip { + template + requires _Zip::_Allow_views<_ViewTypes...> _NODISCARD constexpr bool _Iterator_sentinel_equality_impl( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs) { - using _Difference_type = - _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>; + const auto _Evaluate_tuple_values_lambda = [&_Lhs, &_Rhs]<_STD size_t _CurrIndex>(this const auto& self) { + if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { + if (_STD get<_CurrIndex>(_Lhs._M_Current) == _STD get<_CurrIndex>(_Rhs._M_End)) + return true; - if constexpr (sizeof...(_ViewTypes) == 1) { - return _Difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_End)}; - } else { - auto _Smallest_distance_value = _Difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_End)}; - auto _Smallest_abs_distance_value = - _RANGES distance(_STD get<0>(_Lhs._M_Current), _STD get<0>(_Rhs._M_End)); - - const auto _Evaluate_distance_values_lambda = [&_Lhs, &_Rhs, &_Smallest_distance_value, - &_Smallest_abs_distance_value]<_STD size_t _CurrIndex>( - this const auto& self) { - const auto _Curr_distance_value = - _Difference_type{_STD get<_CurrIndex>(_Lhs._M_Current) - _STD get<_CurrIndex>(_Rhs._M_End)}; - const auto _Curr_abs_distance_value = - _RANGES distance(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_End)); - - if (_Curr_abs_distance_value < _Smallest_abs_distance_value) { - _Smallest_distance_value = _Curr_distance_value; - _Smallest_abs_distance_value = _Curr_abs_distance_value; + static constexpr auto _Next_index = (_CurrIndex + 1); + return self.operator()<_Next_index>(); + } else { + return false; } - - static constexpr auto _Next_index = (_CurrIndex + 1); - self.operator()<_Next_index>(); }; - _Evaluate_distance_values_lambda.operator()<0>(); + return _Evaluate_tuple_values_lambda.operator()<0>(); + } - return _Smallest_distance_value; + template + requires _Zip::_Allow_views<_ViewTypes...> _NODISCARD constexpr _STD + common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...> + _Get_smallest_iterator_sentinel_distance_impl( + const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, + const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs) { + using _Difference_type = + _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>; + + if constexpr (sizeof...(_ViewTypes) == 1) { + return _Difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_End)}; + } else { + auto _Smallest_distance_value = + _Difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_End)}; + auto _Smallest_abs_distance_value = + _RANGES distance(_STD get<0>(_Lhs._M_Current), _STD get<0>(_Rhs._M_End)); + + const auto _Evaluate_distance_values_lambda = + [&_Lhs, &_Rhs, &_Smallest_distance_value, &_Smallest_abs_distance_value]<_STD size_t _CurrIndex>( + this const auto& self) { + const auto _Curr_distance_value = + _Difference_type{_STD get<_CurrIndex>(_Lhs._M_Current) - _STD get<_CurrIndex>(_Rhs._M_End)}; + const auto _Curr_abs_distance_value = + _RANGES distance(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_End)); + + if (_Curr_abs_distance_value < _Smallest_abs_distance_value) { + _Smallest_distance_value = _Curr_distance_value; + _Smallest_abs_distance_value = _Curr_abs_distance_value; + } + + static constexpr auto _Next_index = (_CurrIndex + 1); + self.operator()<_Next_index>(); + }; + + _Evaluate_distance_values_lambda.operator()<0>(); + + return _Smallest_distance_value; + } } - } - namespace views { class _Zip_function { public: _Zip_function() noexcept = default; @@ -7476,8 +7482,10 @@ namespace ranges { } } }; + } // namespace _Zip - inline constexpr _Zip_function zip{}; + namespace views { + inline constexpr _Zip::_Zip_function zip{}; } // namespace views #endif // __cpp_lib_ranges_zip From efe0b06568204b197196943a49c29b8cf32a7f4d Mon Sep 17 00:00:00 2001 From: Tyler Date: Mon, 15 Aug 2022 17:45:59 -0700 Subject: [PATCH 05/91] Added a work-around for P2165R4. --- stl/inc/ranges | 5 +++++ stl/inc/yvals_core.h | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 155424b9bb7..88b8c2c9108 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6846,6 +6846,7 @@ namespace ranges { || ((_RANGES random_access_range<_RangeTypes> && ...) && (_RANGES sized_range<_RangeTypes> && ...)); +#ifndef __cpp_lib_tuple_like template struct _Tuple_or_pair_solver { using _Storage_type = _STD tuple<_RangeTypes...>; @@ -6859,6 +6860,10 @@ namespace ranges { template using _Tuple_or_pair = typename _Tuple_or_pair_solver<_RangeTypes...>::_Storage_type; +#else // ^ Pre-P2165R4 / Post-P2165R4 v + template + using _Tuple_or_pair = _STD tuple<_RangeTypes...>; +#endif // !__cpp_lib_tuple_like template constexpr auto _Create_tuple_transform_lambda(_CallbackType&& _Callback) noexcept { diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h index c4594f2117f..986984e8358 100644 --- a/stl/inc/yvals_core.h +++ b/stl/inc/yvals_core.h @@ -1521,7 +1521,7 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect #define __cpp_lib_ranges_starts_ends_with 202106L #define __cpp_lib_ranges_stride 202207L #define __cpp_lib_ranges_to_container 202202L -#define __cpp_lib_ranges_zip 202208L +#define __cpp_lib_ranges_zip 202110L #endif // __cpp_lib_concepts #define __cpp_lib_spanstream 202106L From 6eacd17922020a69b4df599b037e962a16a8c332 Mon Sep 17 00:00:00 2001 From: Tyler Date: Mon, 15 Aug 2022 18:14:13 -0700 Subject: [PATCH 06/91] Fixed a minor bug with distance calculation. --- stl/inc/ranges | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 88b8c2c9108..7dbb1216a52 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -7467,7 +7467,8 @@ namespace ranges { self.operator()<_Next_index>(); }; - _Evaluate_distance_values_lambda.operator()<0>(); + // Start from index 1, since we already evaluated 0. + _Evaluate_distance_values_lambda.operator()<1>(); return _Smallest_distance_value; } From 4c3f04a9b616b245c12713ea11034ef0b1a43281 Mon Sep 17 00:00:00 2001 From: Tyler Date: Mon, 15 Aug 2022 20:00:54 -0700 Subject: [PATCH 07/91] Fixed Clang compilation errors. --- stl/inc/ranges | 246 ++++++++++++++++++++++++++----------------------- 1 file changed, 132 insertions(+), 114 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 7dbb1216a52..c5ccde54a48 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -7059,17 +7059,17 @@ namespace ranges { enable_borrowed_range> = (_RANGES enable_borrowed_range<_RangeTypes> && ...); namespace _Zip { - template + template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _ViewTypes> requires _Zip::_Allow_views<_ViewTypes...> _NODISCARD constexpr bool _Iterator_sentinel_equality_impl( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs); - template - requires _Zip::_Allow_views<_ViewTypes...> _NODISCARD constexpr _STD - common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...> - _Get_smallest_iterator_sentinel_distance_impl( - const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs); + template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _ViewTypes> + requires _Zip::_Allow_views<_ViewTypes...> + constexpr void _Get_smallest_iterator_sentinel_distance_impl( + const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, + const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs, + auto& _Smallest_distance_value, auto& _Smallest_abs_distance_value); } // namespace _Zip template <_RANGES input_range... _ViewTypes> @@ -7079,17 +7079,18 @@ namespace ranges { private: friend class zip_view<_ViewTypes...>; - template - requires _Zip::_Allow_views<_Views...> _NODISCARD_FRIEND constexpr bool _Zip::_Iterator_sentinel_equality_impl( + template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _Views> + requires _Zip::_Allow_views<_Views...> + friend constexpr bool _Zip::_Iterator_sentinel_equality_impl( const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); - template - requires _Zip::_Allow_views<_Views...> _NODISCARD_FRIEND constexpr _STD - common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _Views>>...> - _Zip::_Get_smallest_iterator_sentinel_distance_impl( - const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); + template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _Views> + requires _Zip::_Allow_views<_Views...> + friend constexpr void _Zip::_Get_smallest_iterator_sentinel_distance_impl( + const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, + const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs, + auto& _Smallest_distance_value, auto& _Smallest_abs_distance_value); using _Iterator_tuple_type = _Zip::_Tuple_or_pair<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>...>; @@ -7207,19 +7208,7 @@ namespace ranges { if constexpr (_Zip::_All_bidirectional<_IsConst, _ViewTypes...>) { return (_Lhs._M_Current == _Rhs._M_Current); } else { - const auto _Compare_elements_lambda = [&_Lhs, &_Rhs]<_STD size_t _CurrIndex>(this const auto& self) { - if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { - if (_STD get<_CurrIndex>(_Lhs._M_Current) == _STD get<_CurrIndex>(_Rhs._M_Current)) - return true; - - static constexpr auto _Next_index = (_CurrIndex + 1); - self.operator()<_Next_index>(); - } else { - return false; - } - }; - - return _Compare_elements_lambda.operator()<0>(); + return _Iterator_equality_impl<0>(_Lhs, _Rhs); } } @@ -7268,27 +7257,9 @@ namespace ranges { auto _Smallest_abs_difference_value = difference_type{_RANGES distance(_STD get<0>(_Lhs._M_Current), _STD get<0>(_Rhs._M_Current))}; - const auto _Evaluate_Distances_Lambda = [&_Lhs, &_Rhs, &_Smallest_difference_value, - &_Smallest_abs_difference_value]<_STD size_t _CurrIndex>( - this const auto& self) { - if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { - const auto _Curr_difference_value = difference_type{ - _STD get<_CurrIndex>(_Lhs._M_Current) - _STD get<_CurrIndex>(_Rhs._M_Current)}; - const auto _Curr_abs_difference_value = difference_type{_RANGES distance( - _STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_Current))}; - - if (_Curr_abs_difference_value < _Smallest_abs_difference_value) { - _Smallest_difference_value = _Curr_difference_value; - _Smallest_abs_difference_value = _Curr_abs_difference_value; - } - - static constexpr auto _Next_index = (_CurrIndex + 1); - self.operator()<_Next_index>(); - } - }; - // Start from index 1, since we already evaluated 0. - _Evaluate_Distances_Lambda.operator()<1>(); + _Iterator_distance_calculation_impl<1>( + _Lhs, _Rhs, _Smallest_difference_value, _Smallest_abs_difference_value); return _Smallest_difference_value; } @@ -7306,19 +7277,70 @@ namespace ranges { noexcept(_RANGES iter_swap(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), _STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())) && ...)) requires(_STD indirectly_swappable<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { - const auto _Perform_swap_lambda = [&_Lhs, &_Rhs]<_STD size_t _CurrIndex>(this const auto& self) { - if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { - _RANGES iter_swap(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_Current)); + _Iterator_swap_impl<0>(_Lhs, _Rhs); + } - static constexpr auto _Next_index = (_CurrIndex + 1); - self.operator()<_Next_index>(); + private: + template <_STD size_t _CurrIndex> + _NODISCARD static constexpr bool _Iterator_equality_impl(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( + noexcept(_Lhs._M_Current == _Rhs._M_Current)) requires(_STD + equality_comparable<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { + if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { + if (_STD get<_CurrIndex>(_Lhs._M_Current) == _STD get<_CurrIndex>(_Rhs._M_Current)) + return true; + + static constexpr auto _Next_index = (_CurrIndex + 1); + return _Iterator_equality_impl<_Next_index>(_Lhs, _Rhs); + } else { + return false; + } + } + + template <_STD size_t _CurrIndex> + static constexpr void _Iterator_distance_calculation_impl(const _Iterator& _Lhs, const _Iterator& _Rhs, + auto& _Smallest_difference_value, + auto& _Smallest_abs_difference_value) noexcept((noexcept(difference_type{ + _RANGES distance( + _STD declval<_RANGES iterator_t< + _Maybe_const<_IsConst, _ViewTypes>>>(), + _STD declval<_RANGES iterator_t< + _Maybe_const<_IsConst, _ViewTypes>>>())}) + && ...) && noexcept(_STD declval() + < _STD declval()) + && _STD is_nothrow_copy_assignable_v< + difference_type>) requires(_STD + sized_sentinel_for<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>, + _RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { + if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { + const auto _Curr_difference_value = + difference_type{_STD get<_CurrIndex>(_Lhs._M_Current) - _STD get<_CurrIndex>(_Rhs._M_Current)}; + const auto _Curr_abs_difference_value = difference_type{ + _RANGES distance(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_Current))}; + + if (_Curr_abs_difference_value < _Smallest_abs_difference_value) { + _Smallest_difference_value = _Curr_difference_value; + _Smallest_abs_difference_value = _Curr_abs_difference_value; } - }; - _Perform_swap_lambda.operator()<0>(); + static constexpr auto _Next_index = (_CurrIndex + 1); + _Iterator_distance_calculation_impl<_Next_index>( + _Lhs, _Rhs, _Smallest_difference_value, _Smallest_abs_difference_value); + } + } + + template <_STD size_t _CurrIndex> + static constexpr void _Iterator_swap_impl(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept(( + noexcept(_RANGES iter_swap(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), + _STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())) + && ...)) requires(_STD indirectly_swappable<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { + if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { + _RANGES iter_swap(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_Current)); + + static constexpr auto _Next_index = (_CurrIndex + 1); + _Iterator_swap_impl<_Next_index>(_Lhs, _Rhs); + } } - private: _Iterator_tuple_type _M_Current; }; @@ -7329,17 +7351,18 @@ namespace ranges { private: friend class zip_view<_ViewTypes...>; - template - requires _Zip::_Allow_views<_Views...> _NODISCARD_FRIEND constexpr bool _Zip::_Iterator_sentinel_equality_impl( + template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _Views> + requires _Zip::_Allow_views<_Views...> + friend constexpr bool _Zip::_Iterator_sentinel_equality_impl( const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); - template - requires _Zip::_Allow_views<_Views...> _NODISCARD_FRIEND constexpr _STD - common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _Views>>...> - _Zip::_Get_smallest_iterator_sentinel_distance_impl( - const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); + template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _Views> + requires _Zip::_Allow_views<_Views...> + friend constexpr void _Zip::_Get_smallest_iterator_sentinel_distance_impl( + const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, + const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs, + auto& _Smallest_distance_value, auto& _Smallest_abs_distance_value); using _Sentinel_tuple_type = _Zip::_Tuple_or_pair<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>...>; @@ -7386,7 +7409,7 @@ namespace ranges { const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, const _Sentinel& _Rhs) noexcept(_Iterator_sentinel_equality_noexcept<_IsConst, _IteratorConst, _ViewTypes...>) /* strengthened */ { - return _Zip::_Iterator_sentinel_equality_impl<_IsConst, _IteratorConst, _ViewTypes...>(_Lhs, _Rhs); + return _Zip::_Iterator_sentinel_equality_impl<0, _IsConst, _IteratorConst, _ViewTypes...>(_Lhs, _Rhs); } template @@ -7396,8 +7419,23 @@ namespace ranges { const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, const _Sentinel& _Rhs) noexcept(_Get_smallest_iterator_sentinel_distance_noexcept<_IsConst, _IteratorConst, _ViewTypes...>) /* strengthened */ { - return _Zip::_Get_smallest_iterator_sentinel_distance_impl<_IsConst, _IteratorConst, _ViewTypes...>( - _Lhs, _Rhs); + using _Difference_type = + _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>; + + if constexpr (sizeof...(_ViewTypes) == 1) { + return _Difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_End)}; + } else { + auto _Smallest_distance_value = + _Difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_End)}; + auto _Smallest_abs_distance_value = + _RANGES distance(_STD get<0>(_Lhs._M_Current), _STD get<0>(_Rhs._M_End)); + + // Start from index 1, since we already evaluated 0. + _Zip::_Get_smallest_iterator_sentinel_distance_impl<1, _IsConst, _IteratorConst, _ViewTypes...>( + _Lhs, _Rhs, _Smallest_distance_value, _Smallest_abs_distance_value); + + return _Smallest_distance_value; + } } template @@ -7414,64 +7452,44 @@ namespace ranges { }; namespace _Zip { - template + template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _ViewTypes> requires _Zip::_Allow_views<_ViewTypes...> _NODISCARD constexpr bool _Iterator_sentinel_equality_impl( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs) { - const auto _Evaluate_tuple_values_lambda = [&_Lhs, &_Rhs]<_STD size_t _CurrIndex>(this const auto& self) { - if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { - if (_STD get<_CurrIndex>(_Lhs._M_Current) == _STD get<_CurrIndex>(_Rhs._M_End)) - return true; - - static constexpr auto _Next_index = (_CurrIndex + 1); - return self.operator()<_Next_index>(); - } else { - return false; - } - }; + if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { + if (_STD get<_CurrIndex>(_Lhs._M_Current) == _STD get<_CurrIndex>(_Rhs._M_End)) + return true; - return _Evaluate_tuple_values_lambda.operator()<0>(); + static constexpr auto _Next_index = (_CurrIndex + 1); + return _Zip::_Iterator_sentinel_equality_impl<_Next_index, _SentinelConst, _IteratorConst, + _ViewTypes...>(_Lhs, _Rhs); + } else { + return false; + } } - template - requires _Zip::_Allow_views<_ViewTypes...> _NODISCARD constexpr _STD - common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...> - _Get_smallest_iterator_sentinel_distance_impl( - const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs) { + template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _ViewTypes> + requires _Zip::_Allow_views<_ViewTypes...> + constexpr void _Get_smallest_iterator_sentinel_distance_impl( + const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, + const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs, + auto& _Smallest_distance_value, auto& _Smallest_abs_distance_value) { using _Difference_type = _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>; - if constexpr (sizeof...(_ViewTypes) == 1) { - return _Difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_End)}; - } else { - auto _Smallest_distance_value = - _Difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_End)}; - auto _Smallest_abs_distance_value = - _RANGES distance(_STD get<0>(_Lhs._M_Current), _STD get<0>(_Rhs._M_End)); - - const auto _Evaluate_distance_values_lambda = - [&_Lhs, &_Rhs, &_Smallest_distance_value, &_Smallest_abs_distance_value]<_STD size_t _CurrIndex>( - this const auto& self) { - const auto _Curr_distance_value = - _Difference_type{_STD get<_CurrIndex>(_Lhs._M_Current) - _STD get<_CurrIndex>(_Rhs._M_End)}; - const auto _Curr_abs_distance_value = - _RANGES distance(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_End)); - - if (_Curr_abs_distance_value < _Smallest_abs_distance_value) { - _Smallest_distance_value = _Curr_distance_value; - _Smallest_abs_distance_value = _Curr_abs_distance_value; - } - - static constexpr auto _Next_index = (_CurrIndex + 1); - self.operator()<_Next_index>(); - }; + const auto _Curr_distance_value = + _Difference_type{_STD get<_CurrIndex>(_Lhs._M_Current) - _STD get<_CurrIndex>(_Rhs._M_End)}; + const auto _Curr_abs_distance_value = + _RANGES distance(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_End)); - // Start from index 1, since we already evaluated 0. - _Evaluate_distance_values_lambda.operator()<1>(); - - return _Smallest_distance_value; + if (_Curr_abs_distance_value < _Smallest_abs_distance_value) { + _Smallest_distance_value = _Curr_distance_value; + _Smallest_abs_distance_value = _Curr_abs_distance_value; } + + static constexpr auto _Next_index = (_CurrIndex + 1); + _Zip::_Get_smallest_iterator_sentinel_distance_impl<_Next_index, _SentinelConst, _IteratorConst, + _ViewTypes...>(_Lhs, _Rhs, _Smallest_distance_value, _Smallest_abs_distance_value); } class _Zip_function { From ed15acab4e5857a69ae06e0c82a370431acc5db5 Mon Sep 17 00:00:00 2001 From: Tyler Date: Mon, 15 Aug 2022 20:22:46 -0700 Subject: [PATCH 08/91] Fixed more Clang compilation errors. --- stl/inc/ranges | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index c5ccde54a48..a97c1d854d7 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -7289,7 +7289,7 @@ namespace ranges { if (_STD get<_CurrIndex>(_Lhs._M_Current) == _STD get<_CurrIndex>(_Rhs._M_Current)) return true; - static constexpr auto _Next_index = (_CurrIndex + 1); + constexpr auto _Next_index = (_CurrIndex + 1); return _Iterator_equality_impl<_Next_index>(_Lhs, _Rhs); } else { return false; @@ -7322,7 +7322,7 @@ namespace ranges { _Smallest_abs_difference_value = _Curr_abs_difference_value; } - static constexpr auto _Next_index = (_CurrIndex + 1); + constexpr auto _Next_index = (_CurrIndex + 1); _Iterator_distance_calculation_impl<_Next_index>( _Lhs, _Rhs, _Smallest_difference_value, _Smallest_abs_difference_value); } @@ -7336,7 +7336,7 @@ namespace ranges { if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { _RANGES iter_swap(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_Current)); - static constexpr auto _Next_index = (_CurrIndex + 1); + constexpr auto _Next_index = (_CurrIndex + 1); _Iterator_swap_impl<_Next_index>(_Lhs, _Rhs); } } @@ -7374,23 +7374,23 @@ namespace ranges { using _Iterator_sentinel_difference_type = _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>; - template + template static constexpr bool _Iterator_sentinel_equality_noexcept = - (noexcept(_STD declval<_RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>() - == _STD declval<_RANGES sentinel_t<_Maybe_const<_SentinelConst, _ViewTypes>>>()) + (noexcept(_STD declval<_RANGES iterator_t<_Maybe_const<_IteratorConst, _Views>>>() + == _STD declval<_RANGES sentinel_t<_Maybe_const<_SentinelConst, _Views>>>()) && ...); - template + template static constexpr bool _Get_smallest_iterator_sentinel_distance_noexcept = - (noexcept(_STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>{ - _RANGES distance(_STD declval<_RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>(), - _STD declval<_RANGES sentinel_t<_Maybe_const<_SentinelConst, _ViewTypes>>>())}) + (noexcept(_STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _Views>>...>{ + _RANGES distance(_STD declval<_RANGES iterator_t<_Maybe_const<_IteratorConst, _Views>>>(), + _STD declval<_RANGES sentinel_t<_Maybe_const<_SentinelConst, _Views>>>())}) && ...) && noexcept(_STD declval<_STD common_type_t<_RANGES - range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>>() + range_difference_t<_Maybe_const<_IteratorConst, _Views>>...>>() < _STD declval<_STD common_type_t< - _RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>>()) + _RANGES range_difference_t<_Maybe_const<_IteratorConst, _Views>>...>>()) && _STD is_nothrow_copy_assignable_v< - _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>>; + _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _Views>>...>>; public: _Sentinel() noexcept(_STD is_nothrow_default_constructible_v<_Sentinel_tuple_type>) = default; @@ -7460,7 +7460,7 @@ namespace ranges { if (_STD get<_CurrIndex>(_Lhs._M_Current) == _STD get<_CurrIndex>(_Rhs._M_End)) return true; - static constexpr auto _Next_index = (_CurrIndex + 1); + constexpr auto _Next_index = (_CurrIndex + 1); return _Zip::_Iterator_sentinel_equality_impl<_Next_index, _SentinelConst, _IteratorConst, _ViewTypes...>(_Lhs, _Rhs); } else { @@ -7487,7 +7487,7 @@ namespace ranges { _Smallest_abs_distance_value = _Curr_abs_distance_value; } - static constexpr auto _Next_index = (_CurrIndex + 1); + constexpr auto _Next_index = (_CurrIndex + 1); _Zip::_Get_smallest_iterator_sentinel_distance_impl<_Next_index, _SentinelConst, _IteratorConst, _ViewTypes...>(_Lhs, _Rhs, _Smallest_distance_value, _Smallest_abs_distance_value); } From 05a9cfb8db23662782e110287a6fc1fcdc38cb4e Mon Sep 17 00:00:00 2001 From: Tyler Date: Mon, 15 Aug 2022 21:02:48 -0700 Subject: [PATCH 09/91] Removed excessive use of _STD and _RANGES. --- stl/inc/ranges | 287 ++++++++++++++++++++++++------------------------- 1 file changed, 138 insertions(+), 149 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index a97c1d854d7..a0039310fde 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6840,35 +6840,33 @@ namespace ranges { #ifdef __cpp_lib_ranges_zip namespace _Zip { template - concept _Is_common = (sizeof...(_RangeTypes) == 1 && (_RANGES common_range<_RangeTypes> && ...)) // - || (!(_RANGES bidirectional_range<_RangeTypes> && ...) - && (_RANGES common_range<_RangeTypes> && ...)) // - || ((_RANGES random_access_range<_RangeTypes> && ...) - && (_RANGES sized_range<_RangeTypes> && ...)); + concept _Is_common = (sizeof...(_RangeTypes) == 1 && (common_range<_RangeTypes> && ...)) // + || (!(bidirectional_range<_RangeTypes> && ...) && (common_range<_RangeTypes> && ...)) // + || ((random_access_range<_RangeTypes> && ...) && (sized_range<_RangeTypes> && ...)); #ifndef __cpp_lib_tuple_like template struct _Tuple_or_pair_solver { - using _Storage_type = _STD tuple<_RangeTypes...>; + using _Storage_type = tuple<_RangeTypes...>; }; template requires(sizeof...(_RangeTypes) == 2) struct _Tuple_or_pair_solver<_RangeTypes...> { - using _Storage_type = _STD pair<_RangeTypes...>; + using _Storage_type = pair<_RangeTypes...>; }; template using _Tuple_or_pair = typename _Tuple_or_pair_solver<_RangeTypes...>::_Storage_type; #else // ^ Pre-P2165R4 / Post-P2165R4 v template - using _Tuple_or_pair = _STD tuple<_RangeTypes...>; + using _Tuple_or_pair = tuple<_RangeTypes...>; #endif // !__cpp_lib_tuple_like template constexpr auto _Create_tuple_transform_lambda(_CallbackType&& _Callback) noexcept { const auto _Created_lambda = [&_Callback](_ViewTupleTypes&&... _View_tuples) { - return _Zip::_Tuple_or_pair<_STD invoke_result_t<_CallbackType&, _ViewTupleTypes>...>{ + return _Zip::_Tuple_or_pair...>{ _STD invoke(_Callback, _STD forward<_ViewTupleTypes>(_View_tuples))...}; }; @@ -6901,22 +6899,22 @@ namespace ranges { } template - concept _All_random_access = (_RANGES random_access_range<_Maybe_const<_IsConst, _Views>> && ...); + concept _All_random_access = (random_access_range<_Maybe_const<_IsConst, _Views>> && ...); template - concept _All_bidirectional = (_RANGES bidirectional_range<_Maybe_const<_IsConst, _Views>> && ...); + concept _All_bidirectional = (bidirectional_range<_Maybe_const<_IsConst, _Views>> && ...); template - concept _All_forward = (_RANGES forward_range<_Maybe_const<_IsConst, _Views>> && ...); + concept _All_forward = (forward_range<_Maybe_const<_IsConst, _Views>> && ...); template - concept _Allow_views = (_RANGES input_range<_ViewTypes> && ...) && (_RANGES view<_ViewTypes> && ...) + concept _Allow_views = (input_range<_ViewTypes> && ...) && (view<_ViewTypes> && ...) && (sizeof...(_ViewTypes) > 0); } // namespace _Zip - template <_RANGES input_range... _ViewTypes> + template requires _Zip::_Allow_views<_ViewTypes...> - class zip_view : public _RANGES view_interface> { + class zip_view : public view_interface> { public: template class _Iterator; @@ -6934,14 +6932,14 @@ namespace ranges { template requires _Zip::_All_forward<_IsConst, _ViewTypes...> struct _Iterator_category_container<_Iterator<_IsConst>> { - using iterator_category = _STD input_iterator_tag; + using iterator_category = input_iterator_tag; }; public: - zip_view() noexcept((_STD is_nothrow_default_constructible_v<_ViewTypes> && ...)) = default; + zip_view() noexcept((is_nothrow_default_constructible_v<_ViewTypes> && ...)) = default; constexpr explicit zip_view(_ViewTypes... _Views) noexcept( - (_STD is_nothrow_move_constructible_v<_ViewTypes> && ...)) // strengthened + (is_nothrow_move_constructible_v<_ViewTypes> && ...)) // strengthened : _M_Views(_STD move(_Views)...) {} _NODISCARD constexpr auto begin() noexcept( @@ -6952,19 +6950,19 @@ namespace ranges { _NODISCARD constexpr auto begin() const noexcept(noexcept(_Zip::_Tuple_transform(_RANGES begin, _M_Views))) // strengthened - requires(_RANGES range&&...) { + requires(range&&...) { return _Iterator{_Zip::_Tuple_transform(_RANGES begin, _M_Views)}; } _NODISCARD constexpr auto end() noexcept( noexcept(_Sentinel{_Zip::_Tuple_transform(_RANGES end, _M_Views)}) && noexcept( _Iterator{_Zip::_Tuple_transform(_RANGES end, _M_Views)}) && noexcept(_RANGES next(begin(), - _STD iter_difference_t<_Iterator>{_Get_signed_size()}))) // strengthened + iter_difference_t<_Iterator>{_Get_signed_size()}))) // strengthened requires(!(_Simple_view<_ViewTypes> && ...)) { if constexpr (!_Zip::_Is_common<_ViewTypes...>) { return _Sentinel{_Zip::_Tuple_transform(_RANGES end, _M_Views)}; - } else if constexpr ((_RANGES random_access_range<_ViewTypes> && ...)) { - return _RANGES next(begin(), _STD iter_difference_t<_Iterator>{_Get_signed_size()}); + } else if constexpr ((random_access_range<_ViewTypes> && ...)) { + return _RANGES next(begin(), iter_difference_t<_Iterator>{_Get_signed_size()}); } else { return _Iterator{_Zip::_Tuple_transform(_RANGES end, _M_Views)}; } @@ -6973,12 +6971,12 @@ namespace ranges { _NODISCARD constexpr auto end() const noexcept(noexcept(_Sentinel{_Zip::_Tuple_transform(_RANGES end, _M_Views)}) && noexcept( _Iterator{_Zip::_Tuple_transform(_RANGES end, _M_Views)}) && noexcept(_RANGES next(begin(), - _STD iter_difference_t<_Iterator>{_Get_signed_size()}))) // strengthened - requires(_RANGES range&&...) { + iter_difference_t<_Iterator>{_Get_signed_size()}))) // strengthened + requires(range&&...) { if constexpr (!_Zip::_Is_common) { return _Sentinel{_Zip::_Tuple_transform(_RANGES end, _M_Views)}; - } else if constexpr ((_RANGES random_access_range && ...)) { - return _RANGES next(begin(), _STD iter_difference_t<_Iterator>{_Get_signed_size()}); + } else if constexpr ((random_access_range && ...)) { + return _RANGES next(begin(), iter_difference_t<_Iterator>{_Get_signed_size()}); } else { return _Iterator{_Zip::_Tuple_transform(_RANGES end, _M_Views)}; } @@ -6986,11 +6984,11 @@ namespace ranges { _NODISCARD constexpr auto size() noexcept( noexcept(_Zip::_Tuple_for_each(_RANGES size, _M_Views))) // strengthened - requires(_RANGES sized_range<_ViewTypes>&&...) { - using _Common_size_type = _STD common_type_t<_RANGES range_size_t<_ViewTypes>...>; + requires(sized_range<_ViewTypes>&&...) { + using _Common_size_type = common_type_t...>; using _Common_unsigned_size_type = _Make_unsigned_like_t<_Common_size_type>; - auto _Smallest_view_size_value = _STD numeric_limits<_Common_unsigned_size_type>::max(); + auto _Smallest_view_size_value = numeric_limits<_Common_unsigned_size_type>::max(); _Zip::_Tuple_for_each( [&_Smallest_view_size_value](_View& _Curr_view) { @@ -7007,11 +7005,11 @@ namespace ranges { _NODISCARD constexpr auto size() const noexcept(noexcept(_Zip::_Tuple_for_each(_RANGES size, _M_Views))) // strengthened - requires(_RANGES sized_range&&...) { - using _Common_size_type = _STD common_type_t<_RANGES range_size_t<_ViewTypes>...>; + requires(sized_range&&...) { + using _Common_size_type = common_type_t...>; using _Common_unsigned_size_type = _Make_unsigned_like_t<_Common_size_type>; - auto _Smallest_view_size_value = _STD numeric_limits<_Common_unsigned_size_type>::max(); + auto _Smallest_view_size_value = numeric_limits<_Common_unsigned_size_type>::max(); _Zip::_Tuple_for_each( [&_Smallest_view_size_value](const _View& _Curr_view) { @@ -7030,7 +7028,7 @@ namespace ranges { _NODISCARD constexpr auto _Get_signed_size() noexcept(noexcept(size())) { const auto _Possibly_unsigned_size = size(); - if constexpr (_STD is_unsigned_v) { + if constexpr (is_unsigned_v) { return static_cast<_Make_signed_like_t>(_Possibly_unsigned_size); } else { return _Possibly_unsigned_size; @@ -7040,7 +7038,7 @@ namespace ranges { _NODISCARD constexpr auto _Get_signed_size() const noexcept(noexcept(size())) { const auto _Possibly_unsigned_size = size(); - if constexpr (_STD is_unsigned_v) { + if constexpr (is_unsigned_v) { return static_cast<_Make_signed_like_t>(_Possibly_unsigned_size); } else { return _Possibly_unsigned_size; @@ -7052,19 +7050,18 @@ namespace ranges { }; template - zip_view(_RangeTypes&&...) -> zip_view<_RANGES views::all_t<_RangeTypes>...>; + zip_view(_RangeTypes&&...) -> zip_view...>; - template <_RANGES input_range... _RangeTypes> - inline constexpr bool - enable_borrowed_range> = (_RANGES enable_borrowed_range<_RangeTypes> && ...); + template + inline constexpr bool enable_borrowed_range> = (enable_borrowed_range<_RangeTypes> && ...); namespace _Zip { - template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _ViewTypes> + template requires _Zip::_Allow_views<_ViewTypes...> _NODISCARD constexpr bool _Iterator_sentinel_equality_impl( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs); - template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _ViewTypes> + template requires _Zip::_Allow_views<_ViewTypes...> constexpr void _Get_smallest_iterator_sentinel_distance_impl( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, @@ -7072,62 +7069,59 @@ namespace ranges { auto& _Smallest_distance_value, auto& _Smallest_abs_distance_value); } // namespace _Zip - template <_RANGES input_range... _ViewTypes> + template requires _Zip::_Allow_views<_ViewTypes...> template class zip_view<_ViewTypes...>::_Iterator : public _Iterator_category_container<_Iterator<_IsConst>> { private: friend class zip_view<_ViewTypes...>; - template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _Views> + template requires _Zip::_Allow_views<_Views...> friend constexpr bool _Zip::_Iterator_sentinel_equality_impl( const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); - template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _Views> + template requires _Zip::_Allow_views<_Views...> friend constexpr void _Zip::_Get_smallest_iterator_sentinel_distance_impl( const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs, auto& _Smallest_distance_value, auto& _Smallest_abs_distance_value); - using _Iterator_tuple_type = _Zip::_Tuple_or_pair<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>...>; + using _Iterator_tuple_type = _Zip::_Tuple_or_pair>...>; constexpr explicit _Iterator(_Iterator_tuple_type _Current) noexcept( - _STD is_nothrow_move_constructible_v<_Iterator_tuple_type>) + is_nothrow_move_constructible_v<_Iterator_tuple_type>) : _M_Current(_STD move(_Current)) {} static constexpr bool _Is_nothrow_dereferenceable = - (noexcept(*(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())) && ...); + (noexcept(*(_STD declval>>())) && ...); static constexpr bool _Is_nothrow_preincrementable = - (noexcept(++(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())) && ...); + (noexcept(++(_STD declval>>())) && ...); static constexpr bool _Is_nothrow_predecrementable = - (noexcept(--(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())) && ...); + (noexcept(--(_STD declval>>())) && ...); public: // NOTE: iterator_category is conditionally present based on whether or not it exists as // a type alias in _Iterator_category_container. - using iterator_concept = - _STD conditional_t<_Zip::_All_random_access<_IsConst, _ViewTypes...>, _STD random_access_iterator_tag, - _STD conditional_t<_Zip::_All_bidirectional<_IsConst, _ViewTypes...>, _STD bidirectional_iterator_tag, - _STD conditional_t<_Zip::_All_forward<_IsConst, _ViewTypes...>, _STD forward_iterator_tag, - _STD input_iterator_tag>>>; + using iterator_concept = conditional_t<_Zip::_All_random_access<_IsConst, _ViewTypes...>, + random_access_iterator_tag, + conditional_t<_Zip::_All_bidirectional<_IsConst, _ViewTypes...>, bidirectional_iterator_tag, + conditional_t<_Zip::_All_forward<_IsConst, _ViewTypes...>, forward_iterator_tag, input_iterator_tag>>>; - using value_type = _Zip::_Tuple_or_pair<_RANGES range_value_t<_Maybe_const<_IsConst, _ViewTypes>>...>; - using difference_type = _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IsConst, _ViewTypes>>...>; + using value_type = _Zip::_Tuple_or_pair>...>; + using difference_type = common_type_t>...>; - _Iterator() noexcept(_STD is_nothrow_default_constructible_v<_Iterator_tuple_type>) = default; + _Iterator() noexcept(is_nothrow_default_constructible_v<_Iterator_tuple_type>) = default; constexpr _Iterator(_Iterator _Rhs) noexcept( - (_STD is_nothrow_move_constructible_v< - _RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) // strengthened + (is_nothrow_move_constructible_v>> && ...)) // strengthened requires(_IsConst - && (_STD convertible_to<_RANGES iterator_t<_ViewTypes>, - _RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) + && (convertible_to, iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) : _M_Current(_STD move(_Rhs._M_Current)) {} _NODISCARD constexpr auto operator*() const noexcept(_Is_nothrow_dereferenceable) /* strengthened */ { @@ -7144,7 +7138,7 @@ namespace ranges { } constexpr _Iterator operator++(int) noexcept( - _Is_nothrow_preincrementable&& _STD is_nothrow_copy_assignable_v<_Iterator<_IsConst>>) // strengthened + _Is_nothrow_preincrementable&& is_nothrow_copy_assignable_v<_Iterator<_IsConst>>) // strengthened requires _Zip::_All_forward<_IsConst, _ViewTypes...> { const auto _Temp = *this; ++(*this); @@ -7159,7 +7153,7 @@ namespace ranges { } constexpr _Iterator operator--(int) noexcept( - _Is_nothrow_predecrementable&& _STD is_nothrow_copy_assignable_v<_Iterator<_IsConst>>) // strengthened + _Is_nothrow_predecrementable&& is_nothrow_copy_assignable_v<_Iterator<_IsConst>>) // strengthened requires _Zip::_All_bidirectional<_IsConst, _ViewTypes...> { const auto _Temp = *this; --(*this); @@ -7168,43 +7162,43 @@ namespace ranges { } constexpr _Iterator& operator+=(difference_type _X) noexcept( - (noexcept(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>() += - _STD iter_difference_t<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>{_X}) + (noexcept(_STD declval>>() += + iter_difference_t>>{_X}) && ...)) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { - _Zip::_Tuple_for_each([&_X]( - _IteratorType& _Itr) { _Itr += _STD iter_difference_t<_IteratorType>{_X}; }, + _Zip::_Tuple_for_each( + [&_X](_IteratorType& _Itr) { _Itr += iter_difference_t<_IteratorType>{_X}; }, _M_Current); return *this; } constexpr _Iterator& operator-=(difference_type _X) noexcept( - (noexcept(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>() -= - _STD iter_difference_t<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>{_X}) + (noexcept(_STD declval>>() -= + iter_difference_t>>{_X}) && ...)) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { - _Zip::_Tuple_for_each([&_X]( - _IteratorType& _Itr) { _Itr -= _STD iter_difference_t<_IteratorType>{_X}; }, + _Zip::_Tuple_for_each( + [&_X](_IteratorType& _Itr) { _Itr -= iter_difference_t<_IteratorType>{_X}; }, _M_Current); return *this; } _NODISCARD constexpr auto operator[](difference_type _X) const - noexcept((noexcept((_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())[_STD - iter_difference_t<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>{_X}]) + noexcept((noexcept((_STD declval>>()) + [iter_difference_t>>{_X}]) && ...)) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { return _Zip::_Tuple_transform( [&_X]( - _IteratorType& _Itr) -> decltype(auto) { return _Itr[_STD iter_difference_t<_IteratorType>{_X}]; }, + _IteratorType& _Itr) -> decltype(auto) { return _Itr[iter_difference_t<_IteratorType>{_X}]; }, _M_Current); } _NODISCARD_FRIEND constexpr bool operator==(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( noexcept(_Lhs._M_Current == _Rhs._M_Current)) // strengthened - requires(_STD equality_comparable<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { + requires(equality_comparable>>&&...) { if constexpr (_Zip::_All_bidirectional<_IsConst, _ViewTypes...>) { return (_Lhs._M_Current == _Rhs._M_Current); } else { @@ -7219,7 +7213,7 @@ namespace ranges { } _NODISCARD_FRIEND constexpr _Iterator operator+(const _Iterator& _Lhs, difference_type _Rhs) noexcept( - noexcept(_STD declval<_Iterator>() += _Rhs) && _STD is_nothrow_copy_assignable_v<_Iterator>) // strengthened + noexcept(_STD declval<_Iterator>() += _Rhs) && is_nothrow_copy_assignable_v<_Iterator>) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { auto _Modified_iterator = _Lhs; _Modified_iterator += _Rhs; @@ -7233,7 +7227,7 @@ namespace ranges { } _NODISCARD_FRIEND constexpr _Iterator operator-(const _Iterator& _Lhs, difference_type _Rhs) noexcept( - noexcept(_STD declval<_Iterator>() -= _Rhs) && _STD is_nothrow_copy_assignable_v<_Iterator>) // strengthened + noexcept(_STD declval<_Iterator>() -= _Rhs) && is_nothrow_copy_assignable_v<_Iterator>) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { auto _Modified_iterator = _Lhs; _Modified_iterator -= _Rhs; @@ -7242,13 +7236,12 @@ namespace ranges { } _NODISCARD_FRIEND constexpr difference_type operator-(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( - (noexcept(difference_type{ - _RANGES distance(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), - _STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())}) + (noexcept(difference_type{_RANGES distance(_STD declval>>(), + _STD declval>>())}) && ...) && noexcept(_STD declval() < _STD declval()) - && _STD is_nothrow_copy_assignable_v) // strengthened - requires(_STD sized_sentinel_for<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>, - _RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { + && is_nothrow_copy_assignable_v) // strengthened + requires(sized_sentinel_for>, + iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { if constexpr (sizeof...(_ViewTypes) == 1) { return difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_Current)}; } else { @@ -7266,25 +7259,23 @@ namespace ranges { } _NODISCARD_FRIEND constexpr auto iter_move(const _Iterator& _Itr) noexcept( - (noexcept(_RANGES iter_move(_STD declval>&>())) - && ...) - && (_STD is_nothrow_move_constructible_v< - _RANGES range_rvalue_reference_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) { + (noexcept(_RANGES iter_move(_STD declval>&>())) && ...) + && (is_nothrow_move_constructible_v>> && ...)) { return _Zip::_Tuple_transform(_RANGES iter_move, _Itr._M_Current); } - friend constexpr void iter_swap(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept(( - noexcept(_RANGES iter_swap(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), - _STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())) - && ...)) requires(_STD indirectly_swappable<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { + friend constexpr void iter_swap(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( + (noexcept(iter_swap(_STD declval>>(), + _STD declval>>())) + && ...)) requires(indirectly_swappable>>&&...) { _Iterator_swap_impl<0>(_Lhs, _Rhs); } private: - template <_STD size_t _CurrIndex> + template _NODISCARD static constexpr bool _Iterator_equality_impl(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( - noexcept(_Lhs._M_Current == _Rhs._M_Current)) requires(_STD - equality_comparable<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { + noexcept(_Lhs._M_Current == _Rhs._M_Current)) requires(equality_comparable>>&&...) { if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { if (_STD get<_CurrIndex>(_Lhs._M_Current) == _STD get<_CurrIndex>(_Rhs._M_Current)) return true; @@ -7296,21 +7287,22 @@ namespace ranges { } } - template <_STD size_t _CurrIndex> + template static constexpr void _Iterator_distance_calculation_impl(const _Iterator& _Lhs, const _Iterator& _Rhs, auto& _Smallest_difference_value, - auto& _Smallest_abs_difference_value) noexcept((noexcept(difference_type{ - _RANGES distance( - _STD declval<_RANGES iterator_t< - _Maybe_const<_IsConst, _ViewTypes>>>(), - _STD declval<_RANGES iterator_t< - _Maybe_const<_IsConst, _ViewTypes>>>())}) - && ...) && noexcept(_STD declval() - < _STD declval()) - && _STD is_nothrow_copy_assignable_v< - difference_type>) requires(_STD - sized_sentinel_for<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>, - _RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { + auto& + _Smallest_abs_difference_value) noexcept((noexcept(difference_type{ + _RANGES distance( + _STD declval< + iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), + _STD declval>>())}) + && ...) && noexcept(_STD declval() + < _STD declval()) + && is_nothrow_copy_assignable_v< + difference_type>) requires(sized_sentinel_for>, + iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { const auto _Curr_difference_value = difference_type{_STD get<_CurrIndex>(_Lhs._M_Current) - _STD get<_CurrIndex>(_Rhs._M_Current)}; @@ -7328,11 +7320,11 @@ namespace ranges { } } - template <_STD size_t _CurrIndex> - static constexpr void _Iterator_swap_impl(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept(( - noexcept(_RANGES iter_swap(_STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), - _STD declval<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>())) - && ...)) requires(_STD indirectly_swappable<_RANGES iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { + template + static constexpr void _Iterator_swap_impl(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( + (noexcept(_RANGES iter_swap(_STD declval>>(), + _STD declval>>())) + && ...)) requires(indirectly_swappable>>&&...) { if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { _RANGES iter_swap(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_Current)); @@ -7344,67 +7336,66 @@ namespace ranges { _Iterator_tuple_type _M_Current; }; - template <_RANGES input_range... _ViewTypes> + template requires _Zip::_Allow_views<_ViewTypes...> template class zip_view<_ViewTypes...>::_Sentinel { private: friend class zip_view<_ViewTypes...>; - template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _Views> + template requires _Zip::_Allow_views<_Views...> friend constexpr bool _Zip::_Iterator_sentinel_equality_impl( const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); - template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _Views> + template requires _Zip::_Allow_views<_Views...> friend constexpr void _Zip::_Get_smallest_iterator_sentinel_distance_impl( const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs, auto& _Smallest_distance_value, auto& _Smallest_abs_distance_value); - using _Sentinel_tuple_type = _Zip::_Tuple_or_pair<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>...>; + using _Sentinel_tuple_type = _Zip::_Tuple_or_pair>...>; constexpr explicit _Sentinel(_Sentinel_tuple_type _End) noexcept( - _STD is_nothrow_copy_assignable_v<_Sentinel_tuple_type>) // strengthened + is_nothrow_copy_assignable_v<_Sentinel_tuple_type>) // strengthened : _M_End(_End) {} template using _Iterator_sentinel_difference_type = - _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>; + common_type_t>...>; - template + template static constexpr bool _Iterator_sentinel_equality_noexcept = - (noexcept(_STD declval<_RANGES iterator_t<_Maybe_const<_IteratorConst, _Views>>>() - == _STD declval<_RANGES sentinel_t<_Maybe_const<_SentinelConst, _Views>>>()) + (noexcept(_STD declval>>() + == _STD declval>>()) && ...); - template + template static constexpr bool _Get_smallest_iterator_sentinel_distance_noexcept = - (noexcept(_STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _Views>>...>{ - _RANGES distance(_STD declval<_RANGES iterator_t<_Maybe_const<_IteratorConst, _Views>>>(), - _STD declval<_RANGES sentinel_t<_Maybe_const<_SentinelConst, _Views>>>())}) - && ...) && noexcept(_STD declval<_STD common_type_t<_RANGES + (noexcept(common_type_t>...>{ + _RANGES distance(_STD declval>>(), + _STD declval>>())}) + && ...) && noexcept(_STD + declval>...>>() - < _STD declval<_STD common_type_t< - _RANGES range_difference_t<_Maybe_const<_IteratorConst, _Views>>...>>()) - && _STD is_nothrow_copy_assignable_v< - _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _Views>>...>>; + < _STD declval< + common_type_t>...>>()) + && is_nothrow_copy_assignable_v>...>>; public: - _Sentinel() noexcept(_STD is_nothrow_default_constructible_v<_Sentinel_tuple_type>) = default; + _Sentinel() noexcept(is_nothrow_default_constructible_v<_Sentinel_tuple_type>) = default; constexpr _Sentinel(_Sentinel _Rhs) noexcept( - _STD is_nothrow_move_constructible_v<_Sentinel_tuple_type>) // strengthened + is_nothrow_move_constructible_v<_Sentinel_tuple_type>) // strengthened requires(_IsConst - && (_STD convertible_to<_RANGES sentinel_t<_ViewTypes>, - _RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) + && (convertible_to, sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) : _M_End(_STD move(_Rhs._M_End)) {} template - requires(_STD sentinel_for<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>, - _RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) + requires(sentinel_for>, + iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) _NODISCARD_FRIEND constexpr bool operator==( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, const _Sentinel& _Rhs) noexcept(_Iterator_sentinel_equality_noexcept<_IsConst, _IteratorConst, @@ -7413,14 +7404,13 @@ namespace ranges { } template - requires(_STD sized_sentinel_for<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>, - _RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) + requires(sized_sentinel_for>, + iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) _NODISCARD_FRIEND constexpr _Iterator_sentinel_difference_type<_IteratorConst> operator-( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, const _Sentinel& _Rhs) noexcept(_Get_smallest_iterator_sentinel_distance_noexcept<_IsConst, _IteratorConst, _ViewTypes...>) /* strengthened */ { - using _Difference_type = - _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>; + using _Difference_type = common_type_t>...>; if constexpr (sizeof...(_ViewTypes) == 1) { return _Difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_End)}; @@ -7439,8 +7429,8 @@ namespace ranges { } template - requires(_STD sized_sentinel_for<_RANGES sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>, - _RANGES iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) + requires(sized_sentinel_for>, + iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) _NODISCARD_FRIEND constexpr _Iterator_sentinel_difference_type<_IteratorConst> operator-(const _Sentinel& _Lhs, const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Rhs) noexcept(noexcept(-(_Rhs - _Lhs))) /* strengthened */ { @@ -7452,7 +7442,7 @@ namespace ranges { }; namespace _Zip { - template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _ViewTypes> + template requires _Zip::_Allow_views<_ViewTypes...> _NODISCARD constexpr bool _Iterator_sentinel_equality_impl( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs) { @@ -7468,14 +7458,13 @@ namespace ranges { } } - template <_STD size_t _CurrIndex, bool _SentinelConst, bool _IteratorConst, _RANGES input_range... _ViewTypes> + template requires _Zip::_Allow_views<_ViewTypes...> constexpr void _Get_smallest_iterator_sentinel_distance_impl( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs, auto& _Smallest_distance_value, auto& _Smallest_abs_distance_value) { - using _Difference_type = - _STD common_type_t<_RANGES range_difference_t<_Maybe_const<_IteratorConst, _ViewTypes>>...>; + using _Difference_type = common_type_t>...>; const auto _Curr_distance_value = _Difference_type{_STD get<_CurrIndex>(_Lhs._M_Current) - _STD get<_CurrIndex>(_Rhs._M_End)}; @@ -7496,11 +7485,11 @@ namespace ranges { public: _Zip_function() noexcept = default; - template <_RANGES input_range... _ViewTypes> - constexpr auto operator()(_ViewTypes&&... _Views) const noexcept(noexcept( - _RANGES views::empty<_STD tuple<>>) && noexcept(zip_view{_STD forward<_ViewTypes>(_Views)...})) { + template + constexpr auto operator()(_ViewTypes&&... _Views) const + noexcept(noexcept(views::empty>) && noexcept(zip_view{_STD forward<_ViewTypes>(_Views)...})) { if constexpr (sizeof...(_ViewTypes) == 0) { - return _RANGES views::empty<_STD tuple<>>; + return views::empty>; } else { return zip_view{_STD forward<_ViewTypes>(_Views)...}; } From dc66136f87743da82dc669bf24a21a31346ce04e Mon Sep 17 00:00:00 2001 From: Tyler Date: Mon, 15 Aug 2022 21:09:06 -0700 Subject: [PATCH 10/91] Removed _Zip::_Tuple_or_pair in favor of std::tuple. --- stl/inc/ranges | 29 +++++------------------------ 1 file changed, 5 insertions(+), 24 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index a0039310fde..7e30b748ddb 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6844,29 +6844,10 @@ namespace ranges { || (!(bidirectional_range<_RangeTypes> && ...) && (common_range<_RangeTypes> && ...)) // || ((random_access_range<_RangeTypes> && ...) && (sized_range<_RangeTypes> && ...)); -#ifndef __cpp_lib_tuple_like - template - struct _Tuple_or_pair_solver { - using _Storage_type = tuple<_RangeTypes...>; - }; - - template - requires(sizeof...(_RangeTypes) == 2) - struct _Tuple_or_pair_solver<_RangeTypes...> { - using _Storage_type = pair<_RangeTypes...>; - }; - - template - using _Tuple_or_pair = typename _Tuple_or_pair_solver<_RangeTypes...>::_Storage_type; -#else // ^ Pre-P2165R4 / Post-P2165R4 v - template - using _Tuple_or_pair = tuple<_RangeTypes...>; -#endif // !__cpp_lib_tuple_like - template constexpr auto _Create_tuple_transform_lambda(_CallbackType&& _Callback) noexcept { const auto _Created_lambda = [&_Callback](_ViewTupleTypes&&... _View_tuples) { - return _Zip::_Tuple_or_pair...>{ + return tuple...>{ _STD invoke(_Callback, _STD forward<_ViewTupleTypes>(_View_tuples))...}; }; @@ -7046,7 +7027,7 @@ namespace ranges { } private: - _Zip::_Tuple_or_pair<_ViewTypes...> _M_Views; + tuple<_ViewTypes...> _M_Views; }; template @@ -7089,7 +7070,7 @@ namespace ranges { const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs, auto& _Smallest_distance_value, auto& _Smallest_abs_distance_value); - using _Iterator_tuple_type = _Zip::_Tuple_or_pair>...>; + using _Iterator_tuple_type = tuple>...>; constexpr explicit _Iterator(_Iterator_tuple_type _Current) noexcept( is_nothrow_move_constructible_v<_Iterator_tuple_type>) @@ -7113,7 +7094,7 @@ namespace ranges { conditional_t<_Zip::_All_bidirectional<_IsConst, _ViewTypes...>, bidirectional_iterator_tag, conditional_t<_Zip::_All_forward<_IsConst, _ViewTypes...>, forward_iterator_tag, input_iterator_tag>>>; - using value_type = _Zip::_Tuple_or_pair>...>; + using value_type = tuple>...>; using difference_type = common_type_t>...>; _Iterator() noexcept(is_nothrow_default_constructible_v<_Iterator_tuple_type>) = default; @@ -7356,7 +7337,7 @@ namespace ranges { const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs, auto& _Smallest_distance_value, auto& _Smallest_abs_distance_value); - using _Sentinel_tuple_type = _Zip::_Tuple_or_pair>...>; + using _Sentinel_tuple_type = tuple>...>; constexpr explicit _Sentinel(_Sentinel_tuple_type _End) noexcept( is_nothrow_copy_assignable_v<_Sentinel_tuple_type>) // strengthened From 409d39ad7dda0f68edb2b11351a307a794aad73e Mon Sep 17 00:00:00 2001 From: Tyler Date: Mon, 15 Aug 2022 21:45:15 -0700 Subject: [PATCH 11/91] Fixed some formatting errors. --- stl/inc/ranges | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 7e30b748ddb..8d69a72cd8c 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -7268,22 +7268,22 @@ namespace ranges { } } + // clang-format off template static constexpr void _Iterator_distance_calculation_impl(const _Iterator& _Lhs, const _Iterator& _Rhs, auto& _Smallest_difference_value, - auto& - _Smallest_abs_difference_value) noexcept((noexcept(difference_type{ - _RANGES distance( - _STD declval< - iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), - _STD declval>>())}) - && ...) && noexcept(_STD declval() - < _STD declval()) - && is_nothrow_copy_assignable_v< - difference_type>) requires(sized_sentinel_for>, - iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { + auto& _Smallest_abs_difference_value) noexcept( + (noexcept(difference_type{_RANGES distance( + _STD declval< + iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), + _STD declval>>())}) + && ...) + && noexcept(_STD declval()< _STD declval()) + && is_nothrow_copy_assignable_v) + requires(sized_sentinel_for>, + iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { + // clang-format on if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { const auto _Curr_difference_value = difference_type{_STD get<_CurrIndex>(_Lhs._M_Current) - _STD get<_CurrIndex>(_Rhs._M_Current)}; From 8932d3bcc03fecc276151f24bc12ddd3dd941677 Mon Sep 17 00:00:00 2001 From: Tyler Date: Mon, 15 Aug 2022 22:02:52 -0700 Subject: [PATCH 12/91] Fixed formatting (for real this time). --- stl/inc/ranges | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 8d69a72cd8c..bfeef3e84cd 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -7278,10 +7278,10 @@ namespace ranges { iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), _STD declval>>())}) - && ...) + && ...) && noexcept(_STD declval()< _STD declval()) - && is_nothrow_copy_assignable_v) - requires(sized_sentinel_for>, + && is_nothrow_copy_assignable_v) + requires(sized_sentinel_for>, iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { // clang-format on if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { From 7ae33ec19a1bda8d927c3f5b69d3655f5e75b564 Mon Sep 17 00:00:00 2001 From: Tyler Date: Tue, 16 Aug 2022 09:14:37 -0700 Subject: [PATCH 13/91] Removed the speculative feature test macro. --- stl/inc/ranges | 2 -- stl/inc/yvals_core.h | 1 - 2 files changed, 3 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index bfeef3e84cd..4c8e0dbee82 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6837,7 +6837,6 @@ namespace ranges { inline constexpr _Stride_fn stride; } // namespace views -#ifdef __cpp_lib_ranges_zip namespace _Zip { template concept _Is_common = (sizeof...(_RangeTypes) == 1 && (common_range<_RangeTypes> && ...)) // @@ -7481,7 +7480,6 @@ namespace ranges { namespace views { inline constexpr _Zip::_Zip_function zip{}; } // namespace views -#endif // __cpp_lib_ranges_zip #ifdef __cpp_lib_ranges_to_container // clang-format off diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h index 986984e8358..c5253c4ec7f 100644 --- a/stl/inc/yvals_core.h +++ b/stl/inc/yvals_core.h @@ -1521,7 +1521,6 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect #define __cpp_lib_ranges_starts_ends_with 202106L #define __cpp_lib_ranges_stride 202207L #define __cpp_lib_ranges_to_container 202202L -#define __cpp_lib_ranges_zip 202110L #endif // __cpp_lib_concepts #define __cpp_lib_spanstream 202106L From 77c6141fb7cacc88dc23d8345b89cd17225e2f8f Mon Sep 17 00:00:00 2001 From: Tyler Date: Tue, 16 Aug 2022 12:30:33 -0700 Subject: [PATCH 14/91] Refactored the implementation to remove recursion. --- stl/inc/ranges | 320 +++++++++++++++++++++---------------------------- 1 file changed, 135 insertions(+), 185 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 4c8e0dbee82..5ea86a5f011 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6878,6 +6878,27 @@ namespace ranges { _STD forward<_TupleType>(_Tuple)); } + template + struct _Offset_index_sequence_solver { + static constexpr auto _Solved_index_sequence{ + _Offset_index_sequence_solver<_DesiredOffset, _OtherIndices...>::_Solved_index_sequence}; + }; + + template + struct _Offset_index_sequence_solver<_DesiredOffset, _DesiredOffset, _OtherIndices...> { + static constexpr auto _Solved_index_sequence{index_sequence<_DesiredOffset, _OtherIndices...>{}}; + }; + + template + requires(_Offset <= _OriginalSequenceSize) + _CONSTEVAL auto _Get_offset_index_sequence() noexcept { + constexpr auto _Create_index_sequence_lambda = [](index_sequence<_Indices...>) { + return _Offset_index_sequence_solver<_Offset, _Indices>::_Solved_index_sequence; + }; + + return _Create_index_sequence_lambda(make_index_sequence<_OriginalSequenceSize>{}); + } + template concept _All_random_access = (random_access_range<_Maybe_const<_IsConst, _Views>> && ...); @@ -7025,6 +7046,11 @@ namespace ranges { } } + template + _NODISCARD static constexpr const auto& _Get_iterator_tuple(const _Iterator<_IteratorConst>& _Itr) noexcept { + return _Itr._M_Current; + } + private: tuple<_ViewTypes...> _M_Views; }; @@ -7036,17 +7062,37 @@ namespace ranges { inline constexpr bool enable_borrowed_range> = (enable_borrowed_range<_RangeTypes> && ...); namespace _Zip { - template - requires _Zip::_Allow_views<_ViewTypes...> _NODISCARD constexpr bool _Iterator_sentinel_equality_impl( - const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs); + template + struct _Misc_iterator_sentinel_noexcept_solver {}; + + template + struct _Misc_iterator_sentinel_noexcept_solver<_ResultType, tuple<_LHSTupleTypes...>, + tuple<_RHSTupleTypes...>> { + static constexpr bool _Is_get_smallest_distance_noexcept = + (noexcept(_ResultType{_STD declval<_LHSTupleTypes>() - _STD declval<_RHSTupleTypes>()}) && ...) + && (noexcept( + _ResultType{_RANGES distance(_STD declval<_LHSTupleTypes>(), _STD declval<_RHSTupleTypes>())}) + && ...)&& noexcept(_STD declval<_ResultType>() < _STD declval<_ResultType>()) + && is_nothrow_copy_assignable_v<_ResultType>; + }; - template - requires _Zip::_Allow_views<_ViewTypes...> - constexpr void _Get_smallest_iterator_sentinel_distance_impl( - const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs, - auto& _Smallest_distance_value, auto& _Smallest_abs_distance_value); + template + struct _Misc_iterator_sentinel_noexcept_solver, tuple<_RHSTupleTypes...>> { + static constexpr bool _Is_evaluate_equality_noexcept = + (noexcept(_STD declval<_LHSTupleTypes>() == _STD declval<_RHSTupleTypes>()) && ...); + }; + + template + requires(tuple_size_v> == tuple_size_v>) + _NODISCARD constexpr _ResultType _Get_smallest_iterator_sentinel_distance(_LHSItrOrSentTuple&& _Lhs_tuple, + _RHSItrOrSentTuple&& _Rhs_tuple) noexcept(_Misc_iterator_sentinel_noexcept_solver<_ResultType, + decay_t<_LHSItrOrSentTuple>, decay_t<_RHSItrOrSentTuple>>::_Is_get_smallest_distance_noexcept); + + template + requires(tuple_size_v> == tuple_size_v>) + _NODISCARD constexpr bool _Evaluate_iterator_sentinel_equality(_LHSItrOrSentTuple&& _Lhs_tuple, + _RHSItrOrSentTuple&& _Rhs_tuple) noexcept(_Misc_iterator_sentinel_noexcept_solver, decay_t<_RHSItrOrSentTuple>>::_Is_evaluate_equality_noexcept); } // namespace _Zip template @@ -7056,19 +7102,6 @@ namespace ranges { private: friend class zip_view<_ViewTypes...>; - template - requires _Zip::_Allow_views<_Views...> - friend constexpr bool _Zip::_Iterator_sentinel_equality_impl( - const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); - - template - requires _Zip::_Allow_views<_Views...> - friend constexpr void _Zip::_Get_smallest_iterator_sentinel_distance_impl( - const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs, - auto& _Smallest_distance_value, auto& _Smallest_abs_distance_value); - using _Iterator_tuple_type = tuple>...>; constexpr explicit _Iterator(_Iterator_tuple_type _Current) noexcept( @@ -7182,7 +7215,7 @@ namespace ranges { if constexpr (_Zip::_All_bidirectional<_IsConst, _ViewTypes...>) { return (_Lhs._M_Current == _Rhs._M_Current); } else { - return _Iterator_equality_impl<0>(_Lhs, _Rhs); + return _Zip::_Evaluate_iterator_sentinel_equality(_Lhs._M_Current, _Rhs._M_Current); } } @@ -7216,26 +7249,11 @@ namespace ranges { } _NODISCARD_FRIEND constexpr difference_type operator-(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( - (noexcept(difference_type{_RANGES distance(_STD declval>>(), - _STD declval>>())}) - && ...) && noexcept(_STD declval() < _STD declval()) - && is_nothrow_copy_assignable_v) // strengthened + noexcept(_Zip::_Get_smallest_iterator_sentinel_distance( + _Lhs._M_Current, _Rhs._M_Current))) // strengthened requires(sized_sentinel_for>, iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { - if constexpr (sizeof...(_ViewTypes) == 1) { - return difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_Current)}; - } else { - auto _Smallest_difference_value = - difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_Current)}; - auto _Smallest_abs_difference_value = - difference_type{_RANGES distance(_STD get<0>(_Lhs._M_Current), _STD get<0>(_Rhs._M_Current))}; - - // Start from index 1, since we already evaluated 0. - _Iterator_distance_calculation_impl<1>( - _Lhs, _Rhs, _Smallest_difference_value, _Smallest_abs_difference_value); - - return _Smallest_difference_value; - } + return _Zip::_Get_smallest_iterator_sentinel_distance(_Lhs._M_Current, _Rhs._M_Current); } _NODISCARD_FRIEND constexpr auto iter_move(const _Iterator& _Itr) noexcept( @@ -7248,71 +7266,15 @@ namespace ranges { (noexcept(iter_swap(_STD declval>>(), _STD declval>>())) && ...)) requires(indirectly_swappable>>&&...) { - _Iterator_swap_impl<0>(_Lhs, _Rhs); - } - - private: - template - _NODISCARD static constexpr bool _Iterator_equality_impl(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( - noexcept(_Lhs._M_Current == _Rhs._M_Current)) requires(equality_comparable>>&&...) { - if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { - if (_STD get<_CurrIndex>(_Lhs._M_Current) == _STD get<_CurrIndex>(_Rhs._M_Current)) - return true; - - constexpr auto _Next_index = (_CurrIndex + 1); - return _Iterator_equality_impl<_Next_index>(_Lhs, _Rhs); - } else { - return false; - } - } - - // clang-format off - template - static constexpr void _Iterator_distance_calculation_impl(const _Iterator& _Lhs, const _Iterator& _Rhs, - auto& _Smallest_difference_value, - auto& _Smallest_abs_difference_value) noexcept( - (noexcept(difference_type{_RANGES distance( - _STD declval< - iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>(), - _STD declval>>())}) - && ...) - && noexcept(_STD declval()< _STD declval()) - && is_nothrow_copy_assignable_v) - requires(sized_sentinel_for>, - iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { - // clang-format on - if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { - const auto _Curr_difference_value = - difference_type{_STD get<_CurrIndex>(_Lhs._M_Current) - _STD get<_CurrIndex>(_Rhs._M_Current)}; - const auto _Curr_abs_difference_value = difference_type{ - _RANGES distance(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_Current))}; - - if (_Curr_abs_difference_value < _Smallest_abs_difference_value) { - _Smallest_difference_value = _Curr_difference_value; - _Smallest_abs_difference_value = _Curr_abs_difference_value; - } - - constexpr auto _Next_index = (_CurrIndex + 1); - _Iterator_distance_calculation_impl<_Next_index>( - _Lhs, _Rhs, _Smallest_difference_value, _Smallest_abs_difference_value); - } - } - - template - static constexpr void _Iterator_swap_impl(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( - (noexcept(_RANGES iter_swap(_STD declval>>(), - _STD declval>>())) - && ...)) requires(indirectly_swappable>>&&...) { - if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { - _RANGES iter_swap(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_Current)); + const auto _Swap_every_pair_lambda = [&_Lhs, &_Rhs ](index_sequence<_Indices...>) { + ((_RANGES iter_swap(_STD get<_Indices>(_Lhs._M_Current), _STD get<_Indices>(_Rhs._M_Current))), ...); + }; - constexpr auto _Next_index = (_CurrIndex + 1); - _Iterator_swap_impl<_Next_index>(_Lhs, _Rhs); - } + constexpr auto _Index_sequence = index_sequence_for<_ViewTypes...>{}; + _Swap_every_pair_lambda(_Index_sequence); } + private: _Iterator_tuple_type _M_Current; }; @@ -7323,19 +7285,6 @@ namespace ranges { private: friend class zip_view<_ViewTypes...>; - template - requires _Zip::_Allow_views<_Views...> - friend constexpr bool _Zip::_Iterator_sentinel_equality_impl( - const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs); - - template - requires _Zip::_Allow_views<_Views...> - friend constexpr void _Zip::_Get_smallest_iterator_sentinel_distance_impl( - const typename zip_view<_Views...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_Views...>::template _Sentinel<_SentinelConst>& _Rhs, - auto& _Smallest_distance_value, auto& _Smallest_abs_distance_value); - using _Sentinel_tuple_type = tuple>...>; constexpr explicit _Sentinel(_Sentinel_tuple_type _End) noexcept( @@ -7346,23 +7295,12 @@ namespace ranges { using _Iterator_sentinel_difference_type = common_type_t>...>; - template - static constexpr bool _Iterator_sentinel_equality_noexcept = - (noexcept(_STD declval>>() - == _STD declval>>()) - && ...); - - template - static constexpr bool _Get_smallest_iterator_sentinel_distance_noexcept = - (noexcept(common_type_t>...>{ - _RANGES distance(_STD declval>>(), - _STD declval>>())}) - && ...) && noexcept(_STD - declval>...>>() - < _STD declval< - common_type_t>...>>()) - && is_nothrow_copy_assignable_v>...>>; + template + static constexpr bool _Iterator_sentinel_equality_noexcept = noexcept( + _Zip::_Evaluate_iterator_sentinel_equality( + _Sentinel::_Get_iterator_tuple( + _STD declval::template _Iterator<_IteratorConst>&>()), + _STD declval<_Sentinel_tuple_type>())); public: _Sentinel() noexcept(is_nothrow_default_constructible_v<_Sentinel_tuple_type>) = default; @@ -7378,9 +7316,8 @@ namespace ranges { iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) _NODISCARD_FRIEND constexpr bool operator==( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const _Sentinel& _Rhs) noexcept(_Iterator_sentinel_equality_noexcept<_IsConst, _IteratorConst, - _ViewTypes...>) /* strengthened */ { - return _Zip::_Iterator_sentinel_equality_impl<0, _IsConst, _IteratorConst, _ViewTypes...>(_Lhs, _Rhs); + const _Sentinel& _Rhs) noexcept(_Iterator_sentinel_equality_noexcept<_IteratorConst>) /* strengthened */ { + return _Zip::_Evaluate_iterator_sentinel_equality(_Sentinel::_Get_iterator_tuple(_Lhs), _Rhs._M_End); } template @@ -7388,24 +7325,14 @@ namespace ranges { iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) _NODISCARD_FRIEND constexpr _Iterator_sentinel_difference_type<_IteratorConst> operator-( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const _Sentinel& _Rhs) noexcept(_Get_smallest_iterator_sentinel_distance_noexcept<_IsConst, _IteratorConst, - _ViewTypes...>) /* strengthened */ { + const _Sentinel& _Rhs) noexcept(noexcept(_Zip:: + _Get_smallest_iterator_sentinel_distance< + common_type_t>...>>( + _Sentinel::_Get_iterator_tuple(_Lhs), _Rhs._M_End))) /* strengthened */ + { using _Difference_type = common_type_t>...>; - - if constexpr (sizeof...(_ViewTypes) == 1) { - return _Difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_End)}; - } else { - auto _Smallest_distance_value = - _Difference_type{_STD get<0>(_Lhs._M_Current) - _STD get<0>(_Rhs._M_End)}; - auto _Smallest_abs_distance_value = - _RANGES distance(_STD get<0>(_Lhs._M_Current), _STD get<0>(_Rhs._M_End)); - - // Start from index 1, since we already evaluated 0. - _Zip::_Get_smallest_iterator_sentinel_distance_impl<1, _IsConst, _IteratorConst, _ViewTypes...>( - _Lhs, _Rhs, _Smallest_distance_value, _Smallest_abs_distance_value); - - return _Smallest_distance_value; - } + return _Zip::_Get_smallest_iterator_sentinel_distance<_Difference_type>( + _Sentinel::_Get_iterator_tuple(_Lhs), _Rhs._M_End); } template @@ -7417,48 +7344,71 @@ namespace ranges { return -(_Rhs - _Lhs); } + private: + template + _NODISCARD static constexpr const auto& _Get_iterator_tuple( + const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Itr) { + return zip_view<_ViewTypes...>::_Get_iterator_tuple(_Itr); + } + private: _Sentinel_tuple_type _M_End; }; namespace _Zip { - template - requires _Zip::_Allow_views<_ViewTypes...> _NODISCARD constexpr bool _Iterator_sentinel_equality_impl( - const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs) { - if constexpr (_CurrIndex != sizeof...(_ViewTypes)) { - if (_STD get<_CurrIndex>(_Lhs._M_Current) == _STD get<_CurrIndex>(_Rhs._M_End)) - return true; - - constexpr auto _Next_index = (_CurrIndex + 1); - return _Zip::_Iterator_sentinel_equality_impl<_Next_index, _SentinelConst, _IteratorConst, - _ViewTypes...>(_Lhs, _Rhs); + template + requires(tuple_size_v> == tuple_size_v>) + _NODISCARD constexpr _ResultType _Get_smallest_iterator_sentinel_distance(_LHSItrOrSentTuple&& _Lhs_tuple, + _RHSItrOrSentTuple&& _Rhs_tuple) noexcept(_Misc_iterator_sentinel_noexcept_solver<_ResultType, + decay_t<_LHSItrOrSentTuple>, decay_t<_RHSItrOrSentTuple>>::_Is_get_smallest_distance_noexcept) { + constexpr auto _Tuple_size = tuple_size_v>; + + if constexpr (_Tuple_size == 1) { + return _ResultType{_STD get<0>(_Lhs_tuple) - _STD get<0>(_Rhs_tuple)}; } else { - return false; - } - } + auto _Smallest_difference_value = _ResultType{_STD get<0>(_Lhs_tuple) - _STD get<0>(_Rhs_tuple)}; + auto _Smallest_abs_difference_value = + _ResultType{_RANGES distance(_STD get<0>(_Lhs_tuple), _STD get<0>(_Rhs_tuple))}; + + const auto _Evaluate_single_distance_lambda = + [&_Lhs_tuple, &_Rhs_tuple, &_Smallest_difference_value, + &_Smallest_abs_difference_value]() { + const auto _Curr_difference_value = + _ResultType{_STD get<_CurrIndex>(_Lhs_tuple) - _STD get<_CurrIndex>(_Rhs_tuple)}; + const auto _Curr_abs_difference_value = _ResultType{ + _RANGES distance(_STD get<_CurrIndex>(_Lhs_tuple), _STD get<_CurrIndex>(_Rhs_tuple))}; + + if (_Curr_abs_difference_value < _Smallest_abs_difference_value) { + _Smallest_difference_value = _Curr_difference_value; + _Smallest_abs_difference_value = _Curr_abs_difference_value; + } + }; - template - requires _Zip::_Allow_views<_ViewTypes...> - constexpr void _Get_smallest_iterator_sentinel_distance_impl( - const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const typename zip_view<_ViewTypes...>::template _Sentinel<_SentinelConst>& _Rhs, - auto& _Smallest_distance_value, auto& _Smallest_abs_distance_value) { - using _Difference_type = common_type_t>...>; + const auto _Evaluate_all_other_distances_lambda = + [&_Evaluate_single_distance_lambda](index_sequence<_Indices...>) { + ((_Evaluate_single_distance_lambda.template operator()<_Indices>()), ...); + }; - const auto _Curr_distance_value = - _Difference_type{_STD get<_CurrIndex>(_Lhs._M_Current) - _STD get<_CurrIndex>(_Rhs._M_End)}; - const auto _Curr_abs_distance_value = - _RANGES distance(_STD get<_CurrIndex>(_Lhs._M_Current), _STD get<_CurrIndex>(_Rhs._M_End)); + // Start from index 1, since we already evaluated 0. + constexpr auto _Offset_index_sequence = _Zip::_Get_offset_index_sequence<_Tuple_size, 1>(); + _Evaluate_all_other_distances_lambda(_Offset_index_sequence); - if (_Curr_abs_distance_value < _Smallest_abs_distance_value) { - _Smallest_distance_value = _Curr_distance_value; - _Smallest_abs_distance_value = _Curr_abs_distance_value; + return _Smallest_difference_value; } + } + + template + requires(tuple_size_v> == tuple_size_v>) + _NODISCARD constexpr bool _Evaluate_iterator_sentinel_equality(_LHSItrOrSentTuple&& _Lhs_tuple, + _RHSItrOrSentTuple&& _Rhs_tuple) noexcept(_Misc_iterator_sentinel_noexcept_solver, decay_t<_RHSItrOrSentTuple>>::_Is_evaluate_equality_noexcept) { + constexpr auto _Index_sequence = make_index_sequence>>{}; + const auto _Evaluate_equality_lambda = + [&_Lhs_tuple, &_Rhs_tuple ](index_sequence<_Indices...>) { + return ((_STD get<_Indices>(_Lhs_tuple) == _STD get<_Indices>(_Rhs_tuple)) || ...); + }; - constexpr auto _Next_index = (_CurrIndex + 1); - _Zip::_Get_smallest_iterator_sentinel_distance_impl<_Next_index, _SentinelConst, _IteratorConst, - _ViewTypes...>(_Lhs, _Rhs, _Smallest_distance_value, _Smallest_abs_distance_value); + return _Evaluate_equality_lambda(_Index_sequence); } class _Zip_function { From 972a5be4fa7afcb02fb47a208f629987e2d00790 Mon Sep 17 00:00:00 2001 From: Tyler Date: Tue, 16 Aug 2022 13:46:50 -0700 Subject: [PATCH 15/91] Fixed some Clang compilation errors. --- stl/inc/ranges | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 5ea86a5f011..6f7c7972906 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6893,7 +6893,7 @@ namespace ranges { requires(_Offset <= _OriginalSequenceSize) _CONSTEVAL auto _Get_offset_index_sequence() noexcept { constexpr auto _Create_index_sequence_lambda = [](index_sequence<_Indices...>) { - return _Offset_index_sequence_solver<_Offset, _Indices>::_Solved_index_sequence; + return _Offset_index_sequence_solver<_Offset, _Indices...>::_Solved_index_sequence; }; return _Create_index_sequence_lambda(make_index_sequence<_OriginalSequenceSize>{}); @@ -7298,7 +7298,7 @@ namespace ranges { template static constexpr bool _Iterator_sentinel_equality_noexcept = noexcept( _Zip::_Evaluate_iterator_sentinel_equality( - _Sentinel::_Get_iterator_tuple( + _Get_iterator_tuple( _STD declval::template _Iterator<_IteratorConst>&>()), _STD declval<_Sentinel_tuple_type>())); @@ -7317,7 +7317,7 @@ namespace ranges { _NODISCARD_FRIEND constexpr bool operator==( const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, const _Sentinel& _Rhs) noexcept(_Iterator_sentinel_equality_noexcept<_IteratorConst>) /* strengthened */ { - return _Zip::_Evaluate_iterator_sentinel_equality(_Sentinel::_Get_iterator_tuple(_Lhs), _Rhs._M_End); + return _Zip::_Evaluate_iterator_sentinel_equality(_Get_iterator_tuple(_Lhs), _Rhs._M_End); } template @@ -7328,11 +7328,11 @@ namespace ranges { const _Sentinel& _Rhs) noexcept(noexcept(_Zip:: _Get_smallest_iterator_sentinel_distance< common_type_t>...>>( - _Sentinel::_Get_iterator_tuple(_Lhs), _Rhs._M_End))) /* strengthened */ + _Get_iterator_tuple(_Lhs), _Rhs._M_End))) /* strengthened */ { using _Difference_type = common_type_t>...>; return _Zip::_Get_smallest_iterator_sentinel_distance<_Difference_type>( - _Sentinel::_Get_iterator_tuple(_Lhs), _Rhs._M_End); + _Get_iterator_tuple(_Lhs), _Rhs._M_End); } template From 4c97a8d0abd2ed812922f8ed7e4d98fd9d536c67 Mon Sep 17 00:00:00 2001 From: Tyler Date: Tue, 16 Aug 2022 14:07:28 -0700 Subject: [PATCH 16/91] Reinstated the __cpp_lib_ranges_zip feature test macro. --- stl/inc/ranges | 2 ++ stl/inc/yvals_core.h | 1 + tests/libcxx/expected_results.txt | 6 ++++-- 3 files changed, 7 insertions(+), 2 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 6f7c7972906..c36f3052cbc 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6837,6 +6837,7 @@ namespace ranges { inline constexpr _Stride_fn stride; } // namespace views +#ifdef __cpp_lib_ranges_zip namespace _Zip { template concept _Is_common = (sizeof...(_RangeTypes) == 1 && (common_range<_RangeTypes> && ...)) // @@ -7430,6 +7431,7 @@ namespace ranges { namespace views { inline constexpr _Zip::_Zip_function zip{}; } // namespace views +#endif // __cpp_lib_ranges_zip #ifdef __cpp_lib_ranges_to_container // clang-format off diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h index c5253c4ec7f..986984e8358 100644 --- a/stl/inc/yvals_core.h +++ b/stl/inc/yvals_core.h @@ -1521,6 +1521,7 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect #define __cpp_lib_ranges_starts_ends_with 202106L #define __cpp_lib_ranges_stride 202207L #define __cpp_lib_ranges_to_container 202202L +#define __cpp_lib_ranges_zip 202110L #endif // __cpp_lib_concepts #define __cpp_lib_spanstream 202106L diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt index 1db9dd69ef3..eb59820e9ec 100644 --- a/tests/libcxx/expected_results.txt +++ b/tests/libcxx/expected_results.txt @@ -238,8 +238,10 @@ std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.deprecated.fail.cp # *** MISSING STL FEATURES *** # P2321R2 zip -std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp FAIL -std/language.support/support.limits/support.limits.general/utility.version.pass.cpp FAIL +# NOTE: We skip these rather than FAILing them because the __cpp_lib_ranges_zip feature test macro is defined +# in the MSVC STL. +std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp SKIPPED +std/language.support/support.limits/support.limits.general/utility.version.pass.cpp SKIPPED # *** MISSING COMPILER FEATURES *** From 2c59b35f399ab727f415fdfb9012d4f767bb2afa Mon Sep 17 00:00:00 2001 From: Tyler Date: Tue, 16 Aug 2022 14:17:43 -0700 Subject: [PATCH 17/91] Added __cpp_lib_ranges_zip to the VSO_0157762 test. --- .../test.compile.pass.cpp | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp index bf41dcd9930..829c5933581 100644 --- a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp +++ b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp @@ -1594,6 +1594,20 @@ STATIC_ASSERT(__cpp_lib_ranges_to_container == 202202L); #endif #endif +#if _HAS_CXX23 && defined(__cpp_lib_concepts) // TRANSITION, GH-395 +#ifndef __cpp_lib_ranges_zip +#error __cpp_lib_ranges_zip is not defined +#elif __cpp_lib_ranges_zip != 202110L +#error __cpp_lib_ranges_zip is not 202110L +#else +STATIC_ASSERT(__cpp_lib_ranges_zip == 202110L); +#endif +#else +#ifdef __cpp_lib_ranges_zip +#error __cpp_lib_ranges_zip is defined +#endif +#endif + #if _HAS_CXX17 #ifndef __cpp_lib_raw_memory_algorithms #error __cpp_lib_raw_memory_algorithms is not defined From 389fe1cdaf750f615ddaa8763c6dfd47b4f2b791 Mon Sep 17 00:00:00 2001 From: Tyler Date: Tue, 16 Aug 2022 14:25:56 -0700 Subject: [PATCH 18/91] Updated the implemented feature list in yvals_core.h. --- stl/inc/yvals_core.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h index 986984e8358..230f992b58f 100644 --- a/stl/inc/yvals_core.h +++ b/stl/inc/yvals_core.h @@ -322,7 +322,7 @@ // P2273R3 constexpr unique_ptr // P2302R4 ranges::contains, ranges::contains_subrange // P2321R2 zip -// (changes to pair, tuple, and vector::reference only) +// (changes to pair, tuple, and vector::reference and std::views::zip only) // P2417R2 More constexpr bitset // P2440R1 ranges::iota, ranges::shift_left, ranges::shift_right // P2441R2 views::join_with From e7e4eb56f9be7d03e9bae9093ed13deb75130064 Mon Sep 17 00:00:00 2001 From: Tyler Nichols Date: Wed, 17 Aug 2022 09:23:34 -0700 Subject: [PATCH 19/91] Update stl/inc/yvals_core.h Co-authored-by: Jakub Mazurkiewicz --- stl/inc/yvals_core.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h index 230f992b58f..9374cc7e4d5 100644 --- a/stl/inc/yvals_core.h +++ b/stl/inc/yvals_core.h @@ -322,7 +322,7 @@ // P2273R3 constexpr unique_ptr // P2302R4 ranges::contains, ranges::contains_subrange // P2321R2 zip -// (changes to pair, tuple, and vector::reference and std::views::zip only) +// (changes to pair, tuple, vector::reference and std::views::zip only) // P2417R2 More constexpr bitset // P2440R1 ranges::iota, ranges::shift_left, ranges::shift_right // P2441R2 views::join_with From 70e2e381e8bc8769314144ef6be331d931eb7d14 Mon Sep 17 00:00:00 2001 From: Tyler Date: Wed, 17 Aug 2022 09:25:48 -0700 Subject: [PATCH 20/91] Applied suggested changes from code review 1. --- stl/inc/ranges | 184 ++++++++++++++++++++++++++++--------------------- 1 file changed, 105 insertions(+), 79 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index c36f3052cbc..083d1714e5d 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6839,14 +6839,14 @@ namespace ranges { #ifdef __cpp_lib_ranges_zip namespace _Zip { - template + template concept _Is_common = (sizeof...(_RangeTypes) == 1 && (common_range<_RangeTypes> && ...)) // || (!(bidirectional_range<_RangeTypes> && ...) && (common_range<_RangeTypes> && ...)) // || ((random_access_range<_RangeTypes> && ...) && (sized_range<_RangeTypes> && ...)); - template + template constexpr auto _Create_tuple_transform_lambda(_CallbackType&& _Callback) noexcept { - const auto _Created_lambda = [&_Callback](_ViewTupleTypes&&... _View_tuples) { + const auto _Created_lambda = [&_Callback](_ViewTupleTypes&&... _View_tuples) { return tuple...>{ _STD invoke(_Callback, _STD forward<_ViewTupleTypes>(_View_tuples))...}; }; @@ -6854,7 +6854,7 @@ namespace ranges { return _Created_lambda; } - template + template constexpr auto _Tuple_transform(_CallbackType&& _Callback, _TupleType&& _Tuple) noexcept( noexcept(_STD apply(_Zip::_Create_tuple_transform_lambda(_STD forward<_CallbackType>(_Callback)), _STD forward<_TupleType>(_Tuple)))) /* strengthened */ { @@ -6862,16 +6862,16 @@ namespace ranges { _STD forward<_TupleType>(_Tuple)); } - template + template constexpr auto _Create_tuple_for_each_lambda(_CallbackType&& _Callback) noexcept { - const auto _Created_lambda = [&_Callback](_ViewTupleTypes&&... _View_tuples) { + const auto _Created_lambda = [&_Callback](_ViewTupleTypes&&... _View_tuples) { (_STD invoke(_Callback, _STD forward<_ViewTupleTypes>(_View_tuples)), ...); }; return _Created_lambda; } - template + template constexpr void _Tuple_for_each(_CallbackType&& _Callback, _TupleType&& _Tuple) noexcept( noexcept(_STD apply(_Zip::_Create_tuple_for_each_lambda(_STD forward<_CallbackType>(_Callback)), _STD forward<_TupleType>(_Tuple)))) /* strengthened */ { @@ -6881,35 +6881,35 @@ namespace ranges { template struct _Offset_index_sequence_solver { - static constexpr auto _Solved_index_sequence{ - _Offset_index_sequence_solver<_DesiredOffset, _OtherIndices...>::_Solved_index_sequence}; + using type = typename _Offset_index_sequence_solver<_DesiredOffset, _OtherIndices...>::type; }; template struct _Offset_index_sequence_solver<_DesiredOffset, _DesiredOffset, _OtherIndices...> { - static constexpr auto _Solved_index_sequence{index_sequence<_DesiredOffset, _OtherIndices...>{}}; + using type = index_sequence<_DesiredOffset, _OtherIndices...>; }; template - requires(_Offset <= _OriginalSequenceSize) _CONSTEVAL auto _Get_offset_index_sequence() noexcept { + _STL_INTERNAL_STATIC_ASSERT(_Offset <= _OriginalSequenceSize); + constexpr auto _Create_index_sequence_lambda = [](index_sequence<_Indices...>) { - return _Offset_index_sequence_solver<_Offset, _Indices...>::_Solved_index_sequence; + return typename _Offset_index_sequence_solver<_Offset, _Indices...>::type{}; }; return _Create_index_sequence_lambda(make_index_sequence<_OriginalSequenceSize>{}); } - template + template concept _All_random_access = (random_access_range<_Maybe_const<_IsConst, _Views>> && ...); - template + template concept _All_bidirectional = (bidirectional_range<_Maybe_const<_IsConst, _Views>> && ...); - template + template concept _All_forward = (forward_range<_Maybe_const<_IsConst, _Views>> && ...); - template + template concept _Allow_views = (input_range<_ViewTypes> && ...) && (view<_ViewTypes> && ...) && (sizeof...(_ViewTypes) > 0); } // namespace _Zip @@ -6925,10 +6925,7 @@ namespace ranges { class _Sentinel; private: - template - friend class _Sentinel; - - template + template struct _Iterator_category_container {}; template @@ -6990,10 +6987,10 @@ namespace ranges { using _Common_size_type = common_type_t...>; using _Common_unsigned_size_type = _Make_unsigned_like_t<_Common_size_type>; - auto _Smallest_view_size_value = numeric_limits<_Common_unsigned_size_type>::max(); + auto _Smallest_view_size_value = (numeric_limits<_Common_unsigned_size_type>::max)(); _Zip::_Tuple_for_each( - [&_Smallest_view_size_value](_View& _Curr_view) { + [&_Smallest_view_size_value](_View& _Curr_view) { const auto _Curr_view_size_value = static_cast<_Common_unsigned_size_type>(_RANGES size(_Curr_view)); @@ -7011,10 +7008,10 @@ namespace ranges { using _Common_size_type = common_type_t...>; using _Common_unsigned_size_type = _Make_unsigned_like_t<_Common_size_type>; - auto _Smallest_view_size_value = numeric_limits<_Common_unsigned_size_type>::max(); + auto _Smallest_view_size_value = (numeric_limits<_Common_unsigned_size_type>::max)(); _Zip::_Tuple_for_each( - [&_Smallest_view_size_value](const _View& _Curr_view) { + [&_Smallest_view_size_value](const _View& _Curr_view) { const auto _Curr_view_size_value = static_cast<_Common_unsigned_size_type>(_RANGES size(_Curr_view)); @@ -7056,17 +7053,17 @@ namespace ranges { tuple<_ViewTypes...> _M_Views; }; - template + template zip_view(_RangeTypes&&...) -> zip_view...>; template inline constexpr bool enable_borrowed_range> = (enable_borrowed_range<_RangeTypes> && ...); namespace _Zip { - template + template struct _Misc_iterator_sentinel_noexcept_solver {}; - template + template struct _Misc_iterator_sentinel_noexcept_solver<_ResultType, tuple<_LHSTupleTypes...>, tuple<_RHSTupleTypes...>> { static constexpr bool _Is_get_smallest_distance_noexcept = @@ -7074,22 +7071,22 @@ namespace ranges { && (noexcept( _ResultType{_RANGES distance(_STD declval<_LHSTupleTypes>(), _STD declval<_RHSTupleTypes>())}) && ...)&& noexcept(_STD declval<_ResultType>() < _STD declval<_ResultType>()) - && is_nothrow_copy_assignable_v<_ResultType>; + && is_nothrow_copy_assignable_v<_ResultType> && is_nothrow_move_constructible_v<_ResultType>; }; - template + template struct _Misc_iterator_sentinel_noexcept_solver, tuple<_RHSTupleTypes...>> { static constexpr bool _Is_evaluate_equality_noexcept = (noexcept(_STD declval<_LHSTupleTypes>() == _STD declval<_RHSTupleTypes>()) && ...); }; - template + template requires(tuple_size_v> == tuple_size_v>) _NODISCARD constexpr _ResultType _Get_smallest_iterator_sentinel_distance(_LHSItrOrSentTuple&& _Lhs_tuple, _RHSItrOrSentTuple&& _Rhs_tuple) noexcept(_Misc_iterator_sentinel_noexcept_solver<_ResultType, decay_t<_LHSItrOrSentTuple>, decay_t<_RHSItrOrSentTuple>>::_Is_get_smallest_distance_noexcept); - template + template requires(tuple_size_v> == tuple_size_v>) _NODISCARD constexpr bool _Evaluate_iterator_sentinel_equality(_LHSItrOrSentTuple&& _Lhs_tuple, _RHSItrOrSentTuple&& _Rhs_tuple) noexcept(_Misc_iterator_sentinel_noexcept_solver class zip_view<_ViewTypes...>::_Iterator : public _Iterator_category_container<_Iterator<_IsConst>> { private: - friend class zip_view<_ViewTypes...>; + friend zip_view<_ViewTypes...>; using _Iterator_tuple_type = tuple>...>; @@ -7148,14 +7145,14 @@ namespace ranges { } constexpr void operator++(int) noexcept(_Is_nothrow_preincrementable) /* strengthened */ { - ++(*this); + ++*this; } constexpr _Iterator operator++(int) noexcept( - _Is_nothrow_preincrementable&& is_nothrow_copy_assignable_v<_Iterator<_IsConst>>) // strengthened + _Is_nothrow_preincrementable&& is_nothrow_copy_constructible_v<_Iterator<_IsConst>>) // strengthened requires _Zip::_All_forward<_IsConst, _ViewTypes...> { const auto _Temp = *this; - ++(*this); + ++*this; return _Temp; } @@ -7167,47 +7164,70 @@ namespace ranges { } constexpr _Iterator operator--(int) noexcept( - _Is_nothrow_predecrementable&& is_nothrow_copy_assignable_v<_Iterator<_IsConst>>) // strengthened + _Is_nothrow_predecrementable&& is_nothrow_copy_constructible_v<_Iterator<_IsConst>>) // strengthened requires _Zip::_All_bidirectional<_IsConst, _ViewTypes...> { const auto _Temp = *this; - --(*this); + --*this; return _Temp; } - constexpr _Iterator& operator+=(difference_type _X) noexcept( + constexpr _Iterator& operator+=(difference_type _Off) noexcept( (noexcept(_STD declval>>() += - iter_difference_t>>{_X}) + iter_difference_t>>{_Off}) && ...)) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { - _Zip::_Tuple_for_each( - [&_X](_IteratorType& _Itr) { _Itr += iter_difference_t<_IteratorType>{_X}; }, - _M_Current); - + if constexpr (is_arithmetic_v) { + _Zip::_Tuple_for_each( + [&_Off]( + _IteratorType& _Itr) { _Itr += static_cast>(_Off); }, + _M_Current); + } else { + _Zip::_Tuple_for_each([&_Off]( + _IteratorType& _Itr) { _Itr += iter_difference_t<_IteratorType>{_Off}; }, + _M_Current); + } + return *this; } - constexpr _Iterator& operator-=(difference_type _X) noexcept( + constexpr _Iterator& operator-=(difference_type _Off) noexcept( (noexcept(_STD declval>>() -= - iter_difference_t>>{_X}) + iter_difference_t>>{_Off}) && ...)) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { - _Zip::_Tuple_for_each( - [&_X](_IteratorType& _Itr) { _Itr -= iter_difference_t<_IteratorType>{_X}; }, - _M_Current); + if constexpr (is_arithmetic_v) { + _Zip::_Tuple_for_each( + [&_Off]( + _IteratorType& _Itr) { _Itr -= static_cast>(_Off); }, + _M_Current); + } else { + _Zip::_Tuple_for_each([&_Off]( + _IteratorType& _Itr) { _Itr -= iter_difference_t<_IteratorType>{_Off}; }, + _M_Current); + } return *this; } - _NODISCARD constexpr auto operator[](difference_type _X) const + _NODISCARD constexpr auto operator[](difference_type _Where) const noexcept((noexcept((_STD declval>>()) - [iter_difference_t>>{_X}]) + [iter_difference_t>>{_Where}]) && ...)) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { - return _Zip::_Tuple_transform( - [&_X]( - _IteratorType& _Itr) -> decltype(auto) { return _Itr[iter_difference_t<_IteratorType>{_X}]; }, - _M_Current); + if constexpr (is_arithmetic_v) { + _Zip::_Tuple_for_each( + [&_Where](_IteratorType& _Itr) -> decltype(auto) { + return _Itr[static_cast>(_Where)]; + }, + _M_Current); + } else { + return _Zip::_Tuple_transform( + [&_Where](_IteratorType& _Itr) -> decltype(auto) { + return _Itr[iter_difference_t<_IteratorType>{_Where}]; + }, + _M_Current); + } } _NODISCARD_FRIEND constexpr bool operator==(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( @@ -7227,7 +7247,7 @@ namespace ranges { } _NODISCARD_FRIEND constexpr _Iterator operator+(const _Iterator& _Lhs, difference_type _Rhs) noexcept( - noexcept(_STD declval<_Iterator>() += _Rhs) && is_nothrow_copy_assignable_v<_Iterator>) // strengthened + noexcept(_STD declval<_Iterator>() += _Rhs) && is_nothrow_copy_constructible_v<_Iterator>) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { auto _Modified_iterator = _Lhs; _Modified_iterator += _Rhs; @@ -7241,7 +7261,7 @@ namespace ranges { } _NODISCARD_FRIEND constexpr _Iterator operator-(const _Iterator& _Lhs, difference_type _Rhs) noexcept( - noexcept(_STD declval<_Iterator>() -= _Rhs) && is_nothrow_copy_assignable_v<_Iterator>) // strengthened + noexcept(_STD declval<_Iterator>() -= _Rhs) && is_nothrow_copy_constructible_v<_Iterator>) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { auto _Modified_iterator = _Lhs; _Modified_iterator -= _Rhs; @@ -7264,15 +7284,14 @@ namespace ranges { } friend constexpr void iter_swap(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( - (noexcept(iter_swap(_STD declval>>(), + (noexcept(_RANGES iter_swap(_STD declval>>(), _STD declval>>())) && ...)) requires(indirectly_swappable>>&&...) { const auto _Swap_every_pair_lambda = [&_Lhs, &_Rhs ](index_sequence<_Indices...>) { ((_RANGES iter_swap(_STD get<_Indices>(_Lhs._M_Current), _STD get<_Indices>(_Rhs._M_Current))), ...); }; - constexpr auto _Index_sequence = index_sequence_for<_ViewTypes...>{}; - _Swap_every_pair_lambda(_Index_sequence); + _Swap_every_pair_lambda(index_sequence_for<_ViewTypes...>{}); } private: @@ -7284,12 +7303,12 @@ namespace ranges { template class zip_view<_ViewTypes...>::_Sentinel { private: - friend class zip_view<_ViewTypes...>; + friend zip_view<_ViewTypes...>; using _Sentinel_tuple_type = tuple>...>; constexpr explicit _Sentinel(_Sentinel_tuple_type _End) noexcept( - is_nothrow_copy_assignable_v<_Sentinel_tuple_type>) // strengthened + is_nothrow_copy_constructible_v<_Sentinel_tuple_type>) // strengthened : _M_End(_End) {} template @@ -7303,6 +7322,9 @@ namespace ranges { _STD declval::template _Iterator<_IteratorConst>&>()), _STD declval<_Sentinel_tuple_type>())); + template + using _Iterator_type = typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>; + public: _Sentinel() noexcept(is_nothrow_default_constructible_v<_Sentinel_tuple_type>) = default; @@ -7315,8 +7337,7 @@ namespace ranges { template requires(sentinel_for>, iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) - _NODISCARD_FRIEND constexpr bool operator==( - const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, + _NODISCARD_FRIEND constexpr bool operator==(const _Iterator_type<_IteratorConst>& _Lhs, const _Sentinel& _Rhs) noexcept(_Iterator_sentinel_equality_noexcept<_IteratorConst>) /* strengthened */ { return _Zip::_Evaluate_iterator_sentinel_equality(_Get_iterator_tuple(_Lhs), _Rhs._M_End); } @@ -7324,10 +7345,9 @@ namespace ranges { template requires(sized_sentinel_for>, iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) - _NODISCARD_FRIEND constexpr _Iterator_sentinel_difference_type<_IteratorConst> operator-( - const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Lhs, - const _Sentinel& _Rhs) noexcept(noexcept(_Zip:: - _Get_smallest_iterator_sentinel_distance< + _NODISCARD_FRIEND constexpr _Iterator_sentinel_difference_type<_IteratorConst> + operator-(const _Iterator_type<_IteratorConst>& _Lhs, const _Sentinel& _Rhs) noexcept( + noexcept(_Zip::_Get_smallest_iterator_sentinel_distance< common_type_t>...>>( _Get_iterator_tuple(_Lhs), _Rhs._M_End))) /* strengthened */ { @@ -7340,15 +7360,13 @@ namespace ranges { requires(sized_sentinel_for>, iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) _NODISCARD_FRIEND constexpr _Iterator_sentinel_difference_type<_IteratorConst> operator-(const _Sentinel& _Lhs, - const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& - _Rhs) noexcept(noexcept(-(_Rhs - _Lhs))) /* strengthened */ { + const _Iterator_type<_IteratorConst>& _Rhs) noexcept(noexcept(-(_Rhs - _Lhs))) /* strengthened */ { return -(_Rhs - _Lhs); } private: template - _NODISCARD static constexpr const auto& _Get_iterator_tuple( - const typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>& _Itr) { + _NODISCARD static constexpr const auto& _Get_iterator_tuple(const _Iterator_type<_IteratorConst>& _Itr) { return zip_view<_ViewTypes...>::_Get_iterator_tuple(_Itr); } @@ -7357,7 +7375,7 @@ namespace ranges { }; namespace _Zip { - template + template requires(tuple_size_v> == tuple_size_v>) _NODISCARD constexpr _ResultType _Get_smallest_iterator_sentinel_distance(_LHSItrOrSentTuple&& _Lhs_tuple, _RHSItrOrSentTuple&& _Rhs_tuple) noexcept(_Misc_iterator_sentinel_noexcept_solver<_ResultType, @@ -7398,7 +7416,7 @@ namespace ranges { } } - template + template requires(tuple_size_v> == tuple_size_v>) _NODISCARD constexpr bool _Evaluate_iterator_sentinel_equality(_LHSItrOrSentTuple&& _Lhs_tuple, _RHSItrOrSentTuple&& _Rhs_tuple) noexcept(_Misc_iterator_sentinel_noexcept_solver + static _CONSTEVAL bool _Is_invocation_noexcept() { + if constexpr (sizeof...(_ViewTypes) == 0) { + // NOTE: views::empty> is nothrow copy-constructible. + return true; + } else { + return noexcept(zip_view{_STD declval<_ViewTypes>()...}); + } + } + public: template - constexpr auto operator()(_ViewTypes&&... _Views) const - noexcept(noexcept(views::empty>) && noexcept(zip_view{_STD forward<_ViewTypes>(_Views)...})) { + constexpr auto operator()(_ViewTypes&&... _Views) const noexcept(_Is_invocation_noexcept<_ViewTypes...>()) { if constexpr (sizeof...(_ViewTypes) == 0) { return views::empty>; } else { @@ -7429,7 +7455,7 @@ namespace ranges { } // namespace _Zip namespace views { - inline constexpr _Zip::_Zip_function zip{}; + inline constexpr _Zip::_Zip_fn zip{}; } // namespace views #endif // __cpp_lib_ranges_zip From ea0a6e605d58dcc9f39ecc60ec818121226d9f6c Mon Sep 17 00:00:00 2001 From: Tyler Date: Wed, 17 Aug 2022 09:30:31 -0700 Subject: [PATCH 21/91] Applied a formatting pass. --- stl/inc/ranges | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 083d1714e5d..6204004ae0e 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -7187,7 +7187,7 @@ namespace ranges { _IteratorType& _Itr) { _Itr += iter_difference_t<_IteratorType>{_Off}; }, _M_Current); } - + return *this; } From c28843d4d5ec6e8ae358638300fbf286a9f6f040 Mon Sep 17 00:00:00 2001 From: Tyler Date: Wed, 17 Aug 2022 09:46:36 -0700 Subject: [PATCH 22/91] Removed _Zip::_Allow_views. --- stl/inc/ranges | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 6204004ae0e..87dbdc1ec85 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6908,15 +6908,11 @@ namespace ranges { template concept _All_forward = (forward_range<_Maybe_const<_IsConst, _Views>> && ...); - - template - concept _Allow_views = (input_range<_ViewTypes> && ...) && (view<_ViewTypes> && ...) - && (sizeof...(_ViewTypes) > 0); } // namespace _Zip template - requires _Zip::_Allow_views<_ViewTypes...> - class zip_view : public view_interface> { + requires(view<_ViewTypes>&&...) + &&(sizeof...(_ViewTypes) > 0) class zip_view : public view_interface> { public: template class _Iterator; @@ -7094,8 +7090,8 @@ namespace ranges { } // namespace _Zip template - requires _Zip::_Allow_views<_ViewTypes...> - template + requires(view<_ViewTypes>&&...) + &&(sizeof...(_ViewTypes) > 0) template class zip_view<_ViewTypes...>::_Iterator : public _Iterator_category_container<_Iterator<_IsConst>> { private: friend zip_view<_ViewTypes...>; @@ -7299,8 +7295,8 @@ namespace ranges { }; template - requires _Zip::_Allow_views<_ViewTypes...> - template + requires(view<_ViewTypes>&&...) + &&(sizeof...(_ViewTypes) > 0) template class zip_view<_ViewTypes...>::_Sentinel { private: friend zip_view<_ViewTypes...>; From f9cc9808ab8d72770b9863403dc4c509c070528b Mon Sep 17 00:00:00 2001 From: Tyler Date: Wed, 17 Aug 2022 10:20:46 -0700 Subject: [PATCH 23/91] Moved and renamed member variables for conformance. --- stl/inc/ranges | 108 ++++++++++++++++++++++++------------------------- 1 file changed, 52 insertions(+), 56 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 87dbdc1ec85..b71eaf24307 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6913,6 +6913,9 @@ namespace ranges { template requires(view<_ViewTypes>&&...) &&(sizeof...(_ViewTypes) > 0) class zip_view : public view_interface> { + private: + tuple<_ViewTypes...> _Ranges; + public: template class _Iterator; @@ -6935,50 +6938,50 @@ namespace ranges { constexpr explicit zip_view(_ViewTypes... _Views) noexcept( (is_nothrow_move_constructible_v<_ViewTypes> && ...)) // strengthened - : _M_Views(_STD move(_Views)...) {} + : _Ranges(_STD move(_Views)...) {} _NODISCARD constexpr auto begin() noexcept( - noexcept(_Zip::_Tuple_transform(_RANGES begin, _M_Views))) // strengthened + noexcept(_Zip::_Tuple_transform(_RANGES begin, _Ranges))) // strengthened requires(!(_Simple_view<_ViewTypes> && ...)) { - return _Iterator{_Zip::_Tuple_transform(_RANGES begin, _M_Views)}; + return _Iterator{_Zip::_Tuple_transform(_RANGES begin, _Ranges)}; } _NODISCARD constexpr auto begin() const - noexcept(noexcept(_Zip::_Tuple_transform(_RANGES begin, _M_Views))) // strengthened + noexcept(noexcept(_Zip::_Tuple_transform(_RANGES begin, _Ranges))) // strengthened requires(range&&...) { - return _Iterator{_Zip::_Tuple_transform(_RANGES begin, _M_Views)}; + return _Iterator{_Zip::_Tuple_transform(_RANGES begin, _Ranges)}; } _NODISCARD constexpr auto end() noexcept( - noexcept(_Sentinel{_Zip::_Tuple_transform(_RANGES end, _M_Views)}) && noexcept( - _Iterator{_Zip::_Tuple_transform(_RANGES end, _M_Views)}) && noexcept(_RANGES next(begin(), + noexcept(_Sentinel{_Zip::_Tuple_transform(_RANGES end, _Ranges)}) && noexcept( + _Iterator{_Zip::_Tuple_transform(_RANGES end, _Ranges)}) && noexcept(_RANGES next(begin(), iter_difference_t<_Iterator>{_Get_signed_size()}))) // strengthened requires(!(_Simple_view<_ViewTypes> && ...)) { if constexpr (!_Zip::_Is_common<_ViewTypes...>) { - return _Sentinel{_Zip::_Tuple_transform(_RANGES end, _M_Views)}; + return _Sentinel{_Zip::_Tuple_transform(_RANGES end, _Ranges)}; } else if constexpr ((random_access_range<_ViewTypes> && ...)) { return _RANGES next(begin(), iter_difference_t<_Iterator>{_Get_signed_size()}); } else { - return _Iterator{_Zip::_Tuple_transform(_RANGES end, _M_Views)}; + return _Iterator{_Zip::_Tuple_transform(_RANGES end, _Ranges)}; } } _NODISCARD constexpr auto end() const - noexcept(noexcept(_Sentinel{_Zip::_Tuple_transform(_RANGES end, _M_Views)}) && noexcept( - _Iterator{_Zip::_Tuple_transform(_RANGES end, _M_Views)}) && noexcept(_RANGES next(begin(), + noexcept(noexcept(_Sentinel{_Zip::_Tuple_transform(_RANGES end, _Ranges)}) && noexcept( + _Iterator{_Zip::_Tuple_transform(_RANGES end, _Ranges)}) && noexcept(_RANGES next(begin(), iter_difference_t<_Iterator>{_Get_signed_size()}))) // strengthened requires(range&&...) { if constexpr (!_Zip::_Is_common) { - return _Sentinel{_Zip::_Tuple_transform(_RANGES end, _M_Views)}; + return _Sentinel{_Zip::_Tuple_transform(_RANGES end, _Ranges)}; } else if constexpr ((random_access_range && ...)) { return _RANGES next(begin(), iter_difference_t<_Iterator>{_Get_signed_size()}); } else { - return _Iterator{_Zip::_Tuple_transform(_RANGES end, _M_Views)}; + return _Iterator{_Zip::_Tuple_transform(_RANGES end, _Ranges)}; } } _NODISCARD constexpr auto size() noexcept( - noexcept(_Zip::_Tuple_for_each(_RANGES size, _M_Views))) // strengthened + noexcept(_Zip::_Tuple_for_each(_RANGES size, _Ranges))) // strengthened requires(sized_range<_ViewTypes>&&...) { using _Common_size_type = common_type_t...>; using _Common_unsigned_size_type = _Make_unsigned_like_t<_Common_size_type>; @@ -6993,13 +6996,13 @@ namespace ranges { if (_Curr_view_size_value < _Smallest_view_size_value) _Smallest_view_size_value = _Curr_view_size_value; }, - _M_Views); + _Ranges); return _Smallest_view_size_value; } _NODISCARD constexpr auto size() const - noexcept(noexcept(_Zip::_Tuple_for_each(_RANGES size, _M_Views))) // strengthened + noexcept(noexcept(_Zip::_Tuple_for_each(_RANGES size, _Ranges))) // strengthened requires(sized_range&&...) { using _Common_size_type = common_type_t...>; using _Common_unsigned_size_type = _Make_unsigned_like_t<_Common_size_type>; @@ -7014,7 +7017,7 @@ namespace ranges { if (_Curr_view_size_value < _Smallest_view_size_value) _Smallest_view_size_value = _Curr_view_size_value; }, - _M_Views); + _Ranges); return _Smallest_view_size_value; } @@ -7042,11 +7045,8 @@ namespace ranges { template _NODISCARD static constexpr const auto& _Get_iterator_tuple(const _Iterator<_IteratorConst>& _Itr) noexcept { - return _Itr._M_Current; + return _Itr._Current; } - - private: - tuple<_ViewTypes...> _M_Views; }; template @@ -7094,13 +7094,14 @@ namespace ranges { &&(sizeof...(_ViewTypes) > 0) template class zip_view<_ViewTypes...>::_Iterator : public _Iterator_category_container<_Iterator<_IsConst>> { private: - friend zip_view<_ViewTypes...>; - using _Iterator_tuple_type = tuple>...>; + _Iterator_tuple_type _Current; + + friend zip_view<_ViewTypes...>; constexpr explicit _Iterator(_Iterator_tuple_type _Current) noexcept( is_nothrow_move_constructible_v<_Iterator_tuple_type>) - : _M_Current(_STD move(_Current)) {} + : _Current(_STD move(_Current)) {} static constexpr bool _Is_nothrow_dereferenceable = (noexcept(*(_STD declval>>())) && ...); @@ -7129,14 +7130,14 @@ namespace ranges { (is_nothrow_move_constructible_v>> && ...)) // strengthened requires(_IsConst && (convertible_to, iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) - : _M_Current(_STD move(_Rhs._M_Current)) {} + : _Current(_STD move(_Rhs._Current)) {} _NODISCARD constexpr auto operator*() const noexcept(_Is_nothrow_dereferenceable) /* strengthened */ { - return _Zip::_Tuple_transform([](auto& _Itr) -> decltype(auto) { return *_Itr; }, _M_Current); + return _Zip::_Tuple_transform([](auto& _Itr) -> decltype(auto) { return *_Itr; }, _Current); } constexpr _Iterator& operator++() noexcept(_Is_nothrow_preincrementable) /* strengthened */ { - _Zip::_Tuple_for_each([](auto& _Itr) { ++_Itr; }, _M_Current); + _Zip::_Tuple_for_each([](auto& _Itr) { ++_Itr; }, _Current); return *this; } @@ -7155,7 +7156,7 @@ namespace ranges { constexpr _Iterator& operator--() noexcept(_Is_nothrow_predecrementable) // strengthened requires _Zip::_All_bidirectional<_IsConst, _ViewTypes...> { - _Zip::_Tuple_for_each([](auto& _Itr) { --_Itr; }, _M_Current); + _Zip::_Tuple_for_each([](auto& _Itr) { --_Itr; }, _Current); return *this; } @@ -7177,11 +7178,11 @@ namespace ranges { _Zip::_Tuple_for_each( [&_Off]( _IteratorType& _Itr) { _Itr += static_cast>(_Off); }, - _M_Current); + _Current); } else { _Zip::_Tuple_for_each([&_Off]( _IteratorType& _Itr) { _Itr += iter_difference_t<_IteratorType>{_Off}; }, - _M_Current); + _Current); } return *this; @@ -7196,11 +7197,11 @@ namespace ranges { _Zip::_Tuple_for_each( [&_Off]( _IteratorType& _Itr) { _Itr -= static_cast>(_Off); }, - _M_Current); + _Current); } else { _Zip::_Tuple_for_each([&_Off]( _IteratorType& _Itr) { _Itr -= iter_difference_t<_IteratorType>{_Off}; }, - _M_Current); + _Current); } return *this; @@ -7216,30 +7217,30 @@ namespace ranges { [&_Where](_IteratorType& _Itr) -> decltype(auto) { return _Itr[static_cast>(_Where)]; }, - _M_Current); + _Current); } else { return _Zip::_Tuple_transform( [&_Where](_IteratorType& _Itr) -> decltype(auto) { return _Itr[iter_difference_t<_IteratorType>{_Where}]; }, - _M_Current); + _Current); } } _NODISCARD_FRIEND constexpr bool operator==(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( - noexcept(_Lhs._M_Current == _Rhs._M_Current)) // strengthened + noexcept(_Lhs._Current == _Rhs._Current)) // strengthened requires(equality_comparable>>&&...) { if constexpr (_Zip::_All_bidirectional<_IsConst, _ViewTypes...>) { - return (_Lhs._M_Current == _Rhs._M_Current); + return (_Lhs._Current == _Rhs._Current); } else { - return _Zip::_Evaluate_iterator_sentinel_equality(_Lhs._M_Current, _Rhs._M_Current); + return _Zip::_Evaluate_iterator_sentinel_equality(_Lhs._Current, _Rhs._Current); } } _NODISCARD_FRIEND constexpr auto operator<=>(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( - noexcept(_Lhs._M_Current <=> _Rhs._M_Current)) // strengthened + noexcept(_Lhs._Current <=> _Rhs._Current)) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { - return (_Lhs._M_Current <=> _Rhs._M_Current); + return (_Lhs._Current <=> _Rhs._Current); } _NODISCARD_FRIEND constexpr _Iterator operator+(const _Iterator& _Lhs, difference_type _Rhs) noexcept( @@ -7267,16 +7268,16 @@ namespace ranges { _NODISCARD_FRIEND constexpr difference_type operator-(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( noexcept(_Zip::_Get_smallest_iterator_sentinel_distance( - _Lhs._M_Current, _Rhs._M_Current))) // strengthened + _Lhs._Current, _Rhs._Current))) // strengthened requires(sized_sentinel_for>, iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { - return _Zip::_Get_smallest_iterator_sentinel_distance(_Lhs._M_Current, _Rhs._M_Current); + return _Zip::_Get_smallest_iterator_sentinel_distance(_Lhs._Current, _Rhs._Current); } _NODISCARD_FRIEND constexpr auto iter_move(const _Iterator& _Itr) noexcept( (noexcept(_RANGES iter_move(_STD declval>&>())) && ...) && (is_nothrow_move_constructible_v>> && ...)) { - return _Zip::_Tuple_transform(_RANGES iter_move, _Itr._M_Current); + return _Zip::_Tuple_transform(_RANGES iter_move, _Itr._Current); } friend constexpr void iter_swap(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( @@ -7284,14 +7285,11 @@ namespace ranges { _STD declval>>())) && ...)) requires(indirectly_swappable>>&&...) { const auto _Swap_every_pair_lambda = [&_Lhs, &_Rhs ](index_sequence<_Indices...>) { - ((_RANGES iter_swap(_STD get<_Indices>(_Lhs._M_Current), _STD get<_Indices>(_Rhs._M_Current))), ...); + ((_RANGES iter_swap(_STD get<_Indices>(_Lhs._Current), _STD get<_Indices>(_Rhs._Current))), ...); }; _Swap_every_pair_lambda(index_sequence_for<_ViewTypes...>{}); } - - private: - _Iterator_tuple_type _M_Current; }; template @@ -7299,13 +7297,14 @@ namespace ranges { &&(sizeof...(_ViewTypes) > 0) template class zip_view<_ViewTypes...>::_Sentinel { private: - friend zip_view<_ViewTypes...>; - using _Sentinel_tuple_type = tuple>...>; + _Sentinel_tuple_type _End; + + friend zip_view<_ViewTypes...>; constexpr explicit _Sentinel(_Sentinel_tuple_type _End) noexcept( is_nothrow_copy_constructible_v<_Sentinel_tuple_type>) // strengthened - : _M_End(_End) {} + : _End(_End) {} template using _Iterator_sentinel_difference_type = @@ -7328,14 +7327,14 @@ namespace ranges { is_nothrow_move_constructible_v<_Sentinel_tuple_type>) // strengthened requires(_IsConst && (convertible_to, sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) - : _M_End(_STD move(_Rhs._M_End)) {} + : _End(_STD move(_Rhs._End)) {} template requires(sentinel_for>, iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>&&...) _NODISCARD_FRIEND constexpr bool operator==(const _Iterator_type<_IteratorConst>& _Lhs, const _Sentinel& _Rhs) noexcept(_Iterator_sentinel_equality_noexcept<_IteratorConst>) /* strengthened */ { - return _Zip::_Evaluate_iterator_sentinel_equality(_Get_iterator_tuple(_Lhs), _Rhs._M_End); + return _Zip::_Evaluate_iterator_sentinel_equality(_Get_iterator_tuple(_Lhs), _Rhs._End); } template @@ -7345,11 +7344,11 @@ namespace ranges { operator-(const _Iterator_type<_IteratorConst>& _Lhs, const _Sentinel& _Rhs) noexcept( noexcept(_Zip::_Get_smallest_iterator_sentinel_distance< common_type_t>...>>( - _Get_iterator_tuple(_Lhs), _Rhs._M_End))) /* strengthened */ + _Get_iterator_tuple(_Lhs), _Rhs._End))) /* strengthened */ { using _Difference_type = common_type_t>...>; return _Zip::_Get_smallest_iterator_sentinel_distance<_Difference_type>( - _Get_iterator_tuple(_Lhs), _Rhs._M_End); + _Get_iterator_tuple(_Lhs), _Rhs._End); } template @@ -7365,9 +7364,6 @@ namespace ranges { _NODISCARD static constexpr const auto& _Get_iterator_tuple(const _Iterator_type<_IteratorConst>& _Itr) { return zip_view<_ViewTypes...>::_Get_iterator_tuple(_Itr); } - - private: - _Sentinel_tuple_type _M_End; }; namespace _Zip { From ccf498e3402379dca97e4417c516adb5055e9897 Mon Sep 17 00:00:00 2001 From: Tyler Date: Wed, 17 Aug 2022 10:28:46 -0700 Subject: [PATCH 24/91] Added const for difference_type parameters. --- stl/inc/ranges | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index b71eaf24307..e562d4f7f8a 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -7169,7 +7169,7 @@ namespace ranges { return _Temp; } - constexpr _Iterator& operator+=(difference_type _Off) noexcept( + constexpr _Iterator& operator+=(const difference_type _Off) noexcept( (noexcept(_STD declval>>() += iter_difference_t>>{_Off}) && ...)) // strengthened @@ -7188,7 +7188,7 @@ namespace ranges { return *this; } - constexpr _Iterator& operator-=(difference_type _Off) noexcept( + constexpr _Iterator& operator-=(const difference_type _Off) noexcept( (noexcept(_STD declval>>() -= iter_difference_t>>{_Off}) && ...)) // strengthened @@ -7207,7 +7207,7 @@ namespace ranges { return *this; } - _NODISCARD constexpr auto operator[](difference_type _Where) const + _NODISCARD constexpr auto operator[](const difference_type _Where) const noexcept((noexcept((_STD declval>>()) [iter_difference_t>>{_Where}]) && ...)) // strengthened @@ -7243,7 +7243,7 @@ namespace ranges { return (_Lhs._Current <=> _Rhs._Current); } - _NODISCARD_FRIEND constexpr _Iterator operator+(const _Iterator& _Lhs, difference_type _Rhs) noexcept( + _NODISCARD_FRIEND constexpr _Iterator operator+(const _Iterator& _Lhs, const difference_type _Rhs) noexcept( noexcept(_STD declval<_Iterator>() += _Rhs) && is_nothrow_copy_constructible_v<_Iterator>) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { auto _Modified_iterator = _Lhs; @@ -7252,12 +7252,12 @@ namespace ranges { return _Modified_iterator; } - _NODISCARD_FRIEND constexpr _Iterator operator+(difference_type _Lhs, const _Iterator& _Rhs) noexcept( + _NODISCARD_FRIEND constexpr _Iterator operator+(const difference_type _Lhs, const _Iterator& _Rhs) noexcept( noexcept(_Rhs + _Lhs)) /* strengthened */ requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { return (_Rhs + _Lhs); } - _NODISCARD_FRIEND constexpr _Iterator operator-(const _Iterator& _Lhs, difference_type _Rhs) noexcept( + _NODISCARD_FRIEND constexpr _Iterator operator-(const _Iterator& _Lhs, const difference_type _Rhs) noexcept( noexcept(_STD declval<_Iterator>() -= _Rhs) && is_nothrow_copy_constructible_v<_Iterator>) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { auto _Modified_iterator = _Lhs; From 2413a20b0220a0f2eba83840eb8353b01c1534f1 Mon Sep 17 00:00:00 2001 From: Tyler Date: Wed, 17 Aug 2022 10:45:13 -0700 Subject: [PATCH 25/91] Moved _Iterator_type further up in _Sentinel. --- stl/inc/ranges | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index e562d4f7f8a..88fc8663785 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -7310,16 +7310,15 @@ namespace ranges { using _Iterator_sentinel_difference_type = common_type_t>...>; + template + using _Iterator_type = typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>; + template static constexpr bool _Iterator_sentinel_equality_noexcept = noexcept( _Zip::_Evaluate_iterator_sentinel_equality( - _Get_iterator_tuple( - _STD declval::template _Iterator<_IteratorConst>&>()), + _Get_iterator_tuple(_STD declval&>()), _STD declval<_Sentinel_tuple_type>())); - template - using _Iterator_type = typename zip_view<_ViewTypes...>::template _Iterator<_IteratorConst>; - public: _Sentinel() noexcept(is_nothrow_default_constructible_v<_Sentinel_tuple_type>) = default; From 1f726e4abd88bdf9aeb549a15f044041652f2404 Mon Sep 17 00:00:00 2001 From: Tyler Date: Wed, 17 Aug 2022 06:01:47 -0700 Subject: [PATCH 26/91] Added the relevant files. --- tests/std/tests/P2321R2_views_zip/env.lst | 4 ++ tests/std/tests/P2321R2_views_zip/test.cpp | 47 ++++++++++++++++++++++ 2 files changed, 51 insertions(+) create mode 100644 tests/std/tests/P2321R2_views_zip/env.lst create mode 100644 tests/std/tests/P2321R2_views_zip/test.cpp diff --git a/tests/std/tests/P2321R2_views_zip/env.lst b/tests/std/tests/P2321R2_views_zip/env.lst new file mode 100644 index 00000000000..885e701dc73 --- /dev/null +++ b/tests/std/tests/P2321R2_views_zip/env.lst @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft Corporation. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +RUNALL_INCLUDE ..\concepts_latest_matrix.lst \ No newline at end of file diff --git a/tests/std/tests/P2321R2_views_zip/test.cpp b/tests/std/tests/P2321R2_views_zip/test.cpp new file mode 100644 index 00000000000..138d95170fb --- /dev/null +++ b/tests/std/tests/P2321R2_views_zip/test.cpp @@ -0,0 +1,47 @@ +// Copyright (c) Microsoft Corporation. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#include +#include + +#include + +template +concept CanViewZip = requires(RangeTypes&&... range) { + std::views::zip(std::forward(range)...); +}; + +template +constexpr bool test_many(RangeType...&& ranges) +{ + using std::ranges::zip_view; + + constexpr bool is_view = + ((std::ranges::view < std::remove_cvref_t && ...) && sizeof...(RangeTypes) > 0); + + template + using AllView = std::views::all_t; + + using VTuple = std::tuple...>; + using R = zip_view; + + STATIC_ASSERT(std::ranges::view); + STATIC_ASSERT(std::ranges::input_range); + STATIC_ASSERT(std::ranges::forward_range == (std::ranges::forward_range> && ...)); + STATIC_ASSERT(std::ranges::bidirectional_range == (std::ranges::bidirectional_range> && ...)); + STATIC_ASSERT(std::ranges::random_access_range == (std::ranges::random_access_range> && ...)); + + // Validate conditional default-initializability + STATIC_ASSERT(std::is_default_constructible_v == (std::is_default_constructible_v> && ...)); + + // Validate conditional borrowed_range + STATIC_ASSERT(std::ranges::borrowed_range == (std::ranges::borrowed_range> && ...)); + + +} + + +int main() +{ + +} \ No newline at end of file From baeb38b893b5066470ebeb0c51b5c54b43c0972f Mon Sep 17 00:00:00 2001 From: Tyler Date: Fri, 19 Aug 2022 19:31:21 -0700 Subject: [PATCH 27/91] Added the first real set of tests. --- stl/inc/ranges | 163 ++-- tests/std/tests/P2321R2_views_zip/env.lst | 2 +- tests/std/tests/P2321R2_views_zip/test.cpp | 885 ++++++++++++++++++++- 3 files changed, 977 insertions(+), 73 deletions(-) diff --git a/stl/inc/ranges b/stl/inc/ranges index 88fc8663785..1853995b9c2 100644 --- a/stl/inc/ranges +++ b/stl/inc/ranges @@ -6933,6 +6933,19 @@ namespace ranges { using iterator_category = input_iterator_tag; }; + template + static constexpr bool _Is_end_noexcept = []() { + if constexpr (!_Zip::_Is_common<_Views...>) { + return noexcept(_Sentinel<_IsConst>{_Zip::_Tuple_transform(_RANGES end, _Ranges)}); + } else if constexpr ((random_access_range<_Views> && ...)) { + return noexcept(_RANGES next(_STD declval<_Maybe_const<_IsConst, zip_view<_ViewTypes...>>>().begin(), + iter_difference_t<_Iterator<_IsConst>>{ + _STD declval<_Maybe_const<_IsConst, zip_view<_ViewTypes...>>>()._Get_signed_size()})); + } else { + return noexcept(_Iterator<_IsConst>{_Zip::_Tuple_transform(_RANGES end, _Ranges)}); + } + }(); + public: zip_view() noexcept((is_nothrow_default_constructible_v<_ViewTypes> && ...)) = default; @@ -6952,10 +6965,7 @@ namespace ranges { return _Iterator{_Zip::_Tuple_transform(_RANGES begin, _Ranges)}; } - _NODISCARD constexpr auto end() noexcept( - noexcept(_Sentinel{_Zip::_Tuple_transform(_RANGES end, _Ranges)}) && noexcept( - _Iterator{_Zip::_Tuple_transform(_RANGES end, _Ranges)}) && noexcept(_RANGES next(begin(), - iter_difference_t<_Iterator>{_Get_signed_size()}))) // strengthened + _NODISCARD constexpr auto end() noexcept(_Is_end_noexcept) // strengthened requires(!(_Simple_view<_ViewTypes> && ...)) { if constexpr (!_Zip::_Is_common<_ViewTypes...>) { return _Sentinel{_Zip::_Tuple_transform(_RANGES end, _Ranges)}; @@ -6966,10 +6976,7 @@ namespace ranges { } } - _NODISCARD constexpr auto end() const - noexcept(noexcept(_Sentinel{_Zip::_Tuple_transform(_RANGES end, _Ranges)}) && noexcept( - _Iterator{_Zip::_Tuple_transform(_RANGES end, _Ranges)}) && noexcept(_RANGES next(begin(), - iter_difference_t<_Iterator>{_Get_signed_size()}))) // strengthened + _NODISCARD constexpr auto end() const noexcept(_Is_end_noexcept) // strengthened requires(range&&...) { if constexpr (!_Zip::_Is_common) { return _Sentinel{_Zip::_Tuple_transform(_RANGES end, _Ranges)}; @@ -7093,6 +7100,18 @@ namespace ranges { requires(view<_ViewTypes>&&...) &&(sizeof...(_ViewTypes) > 0) template class zip_view<_ViewTypes...>::_Iterator : public _Iterator_category_container<_Iterator<_IsConst>> { + public: + // NOTE: iterator_category is conditionally present based on whether or not it exists as + // a type alias in _Iterator_category_container. + + using iterator_concept = conditional_t<_Zip::_All_random_access<_IsConst, _ViewTypes...>, + random_access_iterator_tag, + conditional_t<_Zip::_All_bidirectional<_IsConst, _ViewTypes...>, bidirectional_iterator_tag, + conditional_t<_Zip::_All_forward<_IsConst, _ViewTypes...>, forward_iterator_tag, input_iterator_tag>>>; + + using value_type = tuple>...>; + using difference_type = common_type_t>...>; + private: using _Iterator_tuple_type = tuple>...>; _Iterator_tuple_type _Current; @@ -7103,27 +7122,79 @@ namespace ranges { is_nothrow_move_constructible_v<_Iterator_tuple_type>) : _Current(_STD move(_Current)) {} - static constexpr bool _Is_nothrow_dereferenceable = + static constexpr bool _Is_dereference_nothrow = (noexcept(*(_STD declval>>())) && ...); - static constexpr bool _Is_nothrow_preincrementable = - (noexcept(++(_STD declval>>())) && ...); + static constexpr bool _Is_preincrement_nothrow = + noexcept(_Zip::_Tuple_for_each([](auto& _Itr) { ++_Itr; }, _Current)); - static constexpr bool _Is_nothrow_predecrementable = - (noexcept(--(_STD declval>>())) && ...); + static constexpr bool _Is_predecrement_nothrow = []() { + if constexpr (_Zip::_All_bidirectional<_IsConst, _ViewTypes...>) { + return noexcept(_Zip::_Tuple_for_each([](auto& _Itr) { --_Itr; }, _Current)); + } else { + return false; + } + }(); - public: - // NOTE: iterator_category is conditionally present based on whether or not it exists as - // a type alias in _Iterator_category_container. + static constexpr bool _Is_plus_equals_nothrow = []() { + if constexpr (_Zip::_All_random_access<_IsConst, _ViewTypes...>) { + return (noexcept(_STD declval>&>() += + iter_difference_t>>{ + _STD declval()}) + && ...); + } else { + return false; + } + }(); - using iterator_concept = conditional_t<_Zip::_All_random_access<_IsConst, _ViewTypes...>, - random_access_iterator_tag, - conditional_t<_Zip::_All_bidirectional<_IsConst, _ViewTypes...>, bidirectional_iterator_tag, - conditional_t<_Zip::_All_forward<_IsConst, _ViewTypes...>, forward_iterator_tag, input_iterator_tag>>>; + static constexpr bool _Is_minus_equals_nothrow = []() { + if constexpr (_Zip::_All_random_access<_IsConst, _ViewTypes...>) { + return (noexcept(_STD declval>&>() -= + iter_difference_t>>{ + _STD declval()}) + && ...); + } else { + return false; + } + }(); - using value_type = tuple>...>; - using difference_type = common_type_t>...>; + static constexpr bool _Is_brace_indexing_nothrow = []() { + if constexpr (_Zip::_All_random_access<_IsConst, _ViewTypes...>) { + return (noexcept((_STD declval>>())[iter_difference_t< + iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>{_STD declval()}]) + && ...); + } else { + return false; + } + }(); + static constexpr bool _Is_equality_comparison_nothrow = []() { + if constexpr ((equality_comparable>> && ...)) { + return noexcept(_STD declval<_Iterator_tuple_type>() == _STD declval<_Iterator_tuple_type>()); + } else { + return false; + } + }(); + + static constexpr bool _Is_three_way_comparison_nothrow = []() { + if constexpr (_Zip::_All_random_access<_IsConst, _ViewTypes...>) { + return noexcept(_STD declval<_Iterator_tuple_type>() <=> _STD declval<_Iterator_tuple_type>()); + } else { + return false; + } + }(); + + static constexpr bool _Is_iterator_difference_nothrow = []() { + if constexpr ((sized_sentinel_for>, + iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) { + return noexcept(_Zip::_Get_smallest_iterator_sentinel_distance( + _STD declval<_Iterator_tuple_type>(), _STD declval<_Iterator_tuple_type>())); + } else { + return false; + } + }(); + + public: _Iterator() noexcept(is_nothrow_default_constructible_v<_Iterator_tuple_type>) = default; constexpr _Iterator(_Iterator _Rhs) noexcept( @@ -7132,21 +7203,21 @@ namespace ranges { && (convertible_to, iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)) : _Current(_STD move(_Rhs._Current)) {} - _NODISCARD constexpr auto operator*() const noexcept(_Is_nothrow_dereferenceable) /* strengthened */ { + _NODISCARD constexpr auto operator*() const noexcept(_Is_dereference_nothrow) /* strengthened */ { return _Zip::_Tuple_transform([](auto& _Itr) -> decltype(auto) { return *_Itr; }, _Current); } - constexpr _Iterator& operator++() noexcept(_Is_nothrow_preincrementable) /* strengthened */ { + constexpr _Iterator& operator++() noexcept(_Is_preincrement_nothrow) /* strengthened */ { _Zip::_Tuple_for_each([](auto& _Itr) { ++_Itr; }, _Current); return *this; } - constexpr void operator++(int) noexcept(_Is_nothrow_preincrementable) /* strengthened */ { + constexpr void operator++(int) noexcept(_Is_preincrement_nothrow) /* strengthened */ { ++*this; } constexpr _Iterator operator++(int) noexcept( - _Is_nothrow_preincrementable&& is_nothrow_copy_constructible_v<_Iterator<_IsConst>>) // strengthened + _Is_preincrement_nothrow&& is_nothrow_copy_constructible_v<_Iterator<_IsConst>>) // strengthened requires _Zip::_All_forward<_IsConst, _ViewTypes...> { const auto _Temp = *this; ++*this; @@ -7154,14 +7225,14 @@ namespace ranges { return _Temp; } - constexpr _Iterator& operator--() noexcept(_Is_nothrow_predecrementable) // strengthened + constexpr _Iterator& operator--() noexcept(_Is_predecrement_nothrow) // strengthened requires _Zip::_All_bidirectional<_IsConst, _ViewTypes...> { _Zip::_Tuple_for_each([](auto& _Itr) { --_Itr; }, _Current); return *this; } constexpr _Iterator operator--(int) noexcept( - _Is_nothrow_predecrementable&& is_nothrow_copy_constructible_v<_Iterator<_IsConst>>) // strengthened + _Is_predecrement_nothrow&& is_nothrow_copy_constructible_v<_Iterator<_IsConst>>) // strengthened requires _Zip::_All_bidirectional<_IsConst, _ViewTypes...> { const auto _Temp = *this; --*this; @@ -7169,10 +7240,7 @@ namespace ranges { return _Temp; } - constexpr _Iterator& operator+=(const difference_type _Off) noexcept( - (noexcept(_STD declval>>() += - iter_difference_t>>{_Off}) - && ...)) // strengthened + constexpr _Iterator& operator+=(const difference_type _Off) noexcept(_Is_plus_equals_nothrow) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { if constexpr (is_arithmetic_v) { _Zip::_Tuple_for_each( @@ -7188,10 +7256,7 @@ namespace ranges { return *this; } - constexpr _Iterator& operator-=(const difference_type _Off) noexcept( - (noexcept(_STD declval>>() -= - iter_difference_t>>{_Off}) - && ...)) // strengthened + constexpr _Iterator& operator-=(const difference_type _Off) noexcept(_Is_minus_equals_nothrow) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { if constexpr (is_arithmetic_v) { _Zip::_Tuple_for_each( @@ -7208,12 +7273,10 @@ namespace ranges { } _NODISCARD constexpr auto operator[](const difference_type _Where) const - noexcept((noexcept((_STD declval>>()) - [iter_difference_t>>{_Where}]) - && ...)) // strengthened + noexcept(_Is_brace_indexing_nothrow) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { if constexpr (is_arithmetic_v) { - _Zip::_Tuple_for_each( + return _Zip::_Tuple_transform( [&_Where](_IteratorType& _Itr) -> decltype(auto) { return _Itr[static_cast>(_Where)]; }, @@ -7228,7 +7291,7 @@ namespace ranges { } _NODISCARD_FRIEND constexpr bool operator==(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( - noexcept(_Lhs._Current == _Rhs._Current)) // strengthened + _Is_equality_comparison_nothrow) // strengthened requires(equality_comparable>>&&...) { if constexpr (_Zip::_All_bidirectional<_IsConst, _ViewTypes...>) { return (_Lhs._Current == _Rhs._Current); @@ -7238,7 +7301,7 @@ namespace ranges { } _NODISCARD_FRIEND constexpr auto operator<=>(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( - noexcept(_Lhs._Current <=> _Rhs._Current)) // strengthened + _Is_three_way_comparison_nothrow) // strengthened requires _Zip::_All_random_access<_IsConst, _ViewTypes...> { return (_Lhs._Current <=> _Rhs._Current); } @@ -7267,8 +7330,7 @@ namespace ranges { } _NODISCARD_FRIEND constexpr difference_type operator-(const _Iterator& _Lhs, const _Iterator& _Rhs) noexcept( - noexcept(_Zip::_Get_smallest_iterator_sentinel_distance( - _Lhs._Current, _Rhs._Current))) // strengthened + _Is_iterator_difference_nothrow) // strengthened requires(sized_sentinel_for>, iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>&&...) { return _Zip::_Get_smallest_iterator_sentinel_distance(_Lhs._Current, _Rhs._Current); @@ -7423,23 +7485,24 @@ namespace ranges { struct _Zip_fn { private: - template + template static _CONSTEVAL bool _Is_invocation_noexcept() { if constexpr (sizeof...(_ViewTypes) == 0) { // NOTE: views::empty> is nothrow copy-constructible. return true; } else { - return noexcept(zip_view{_STD declval<_ViewTypes>()...}); + return noexcept(zip_view<_ViewTypes...>{_STD declval<_ViewTypes>()...}); } } public: - template - constexpr auto operator()(_ViewTypes&&... _Views) const noexcept(_Is_invocation_noexcept<_ViewTypes...>()) { + template + constexpr auto operator()(_ViewTypes&&... _Views) const + noexcept(_Is_invocation_noexcept...>()) { if constexpr (sizeof...(_ViewTypes) == 0) { - return views::empty>; + return empty_view>{}; } else { - return zip_view{_STD forward<_ViewTypes>(_Views)...}; + return zip_view...>{_Views...}; } } }; diff --git a/tests/std/tests/P2321R2_views_zip/env.lst b/tests/std/tests/P2321R2_views_zip/env.lst index 885e701dc73..bda799c5c6e 100644 --- a/tests/std/tests/P2321R2_views_zip/env.lst +++ b/tests/std/tests/P2321R2_views_zip/env.lst @@ -1,4 +1,4 @@ # Copyright (c) Microsoft Corporation. # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -RUNALL_INCLUDE ..\concepts_latest_matrix.lst \ No newline at end of file +RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst \ No newline at end of file diff --git a/tests/std/tests/P2321R2_views_zip/test.cpp b/tests/std/tests/P2321R2_views_zip/test.cpp index 138d95170fb..c01d1827a90 100644 --- a/tests/std/tests/P2321R2_views_zip/test.cpp +++ b/tests/std/tests/P2321R2_views_zip/test.cpp @@ -1,47 +1,888 @@ // Copyright (c) Microsoft Corporation. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +#include +#include +#include #include +#include #include #include -template +template concept CanViewZip = requires(RangeTypes&&... range) { std::views::zip(std::forward(range)...); }; -template -constexpr bool test_many(RangeType...&& ranges) -{ - using std::ranges::zip_view; +template +using AllView = std::views::all_t; - constexpr bool is_view = - ((std::ranges::view < std::remove_cvref_t && ...) && sizeof...(RangeTypes) > 0); +template +concept CanTestElementType = + (std::copy_constructible && std::equality_comparable); // Required for iter_swap test - template - using AllView = std::views::all_t; +template + requires(CanTestElementType&& CanTestElementType&& CanTestElementType) +class three_element_test_container { +private: + std::array type_one_array; + std::array type_two_array; + std::array type_three_array; - using VTuple = std::tuple...>; - using R = zip_view; +public: + using element_tuple_type = std::tuple; + using const_element_tuple_type = std::tuple; - STATIC_ASSERT(std::ranges::view); - STATIC_ASSERT(std::ranges::input_range); - STATIC_ASSERT(std::ranges::forward_range == (std::ranges::forward_range> && ...)); - STATIC_ASSERT(std::ranges::bidirectional_range == (std::ranges::bidirectional_range> && ...)); - STATIC_ASSERT(std::ranges::random_access_range == (std::ranges::random_access_range> && ...)); + using reference_tuple_type = std::tuple; + using const_reference_tuple_type = std::tuple; + using rvalue_reference_tuple_type = std::tuple; + using const_rvalue_reference_tuple_type = std::tuple; - // Validate conditional default-initializability - STATIC_ASSERT(std::is_default_constructible_v == (std::is_default_constructible_v> && ...)); + static constexpr std::size_t smallest_array_size = (std::min)(Type1Size, (std::min)(Type2Size, Type3Size)); - // Validate conditional borrowed_range - STATIC_ASSERT(std::ranges::borrowed_range == (std::ranges::borrowed_range> && ...)); + constexpr three_element_test_container(const std::array type_one_init_arr, + const std::array type_two_init_arr, const std::array type_three_init_arr) + : type_one_array(type_one_init_arr), type_two_array(type_two_init_arr), type_three_array(type_three_init_arr) {} + template + constexpr auto get_element_span() { + STATIC_ASSERT(ElementIndex < 3); + if constexpr (ElementIndex == 0) + return std::span{type_one_array}; + + else if constexpr (ElementIndex == 1) + return std::span{type_two_array}; + + else + return std::span{type_three_array}; + } + + template + constexpr auto get_element_span() const { + STATIC_ASSERT(ElementIndex < 3); + + if constexpr (ElementIndex == 0) + return std::span, Type1Size>{type_one_array}; + + else if constexpr (ElementIndex == 1) + return std::span, Type2Size>{type_two_array}; + + else + return std::span, Type3Size>{type_three_array}; + } + + template + constexpr auto& get_underlying_element_array() { + STATIC_ASSERT(ElementIndex < 3); + + if constexpr (ElementIndex == 0) + return type_one_array; + + else if constexpr (ElementIndex == 1) + return type_two_array; + + else + return type_three_array; + } + + template + constexpr const auto& get_underlying_element_array() const { + STATIC_ASSERT(ElementIndex < 3); + + if constexpr (ElementIndex == 0) + return type_one_array; + + else if constexpr (ElementIndex == 1) + return type_two_array; + + else + return type_three_array; + } + + constexpr reference_tuple_type get_expected_element_tuple(const std::size_t index) { + assert(index < smallest_array_size); + return reference_tuple_type{type_one_array[index], type_two_array[index], type_three_array[index]}; + } + + constexpr const_reference_tuple_type get_expected_element_tuple(const std::size_t index) const { + assert(index < smallest_array_size); + return const_reference_tuple_type{type_one_array[index], type_two_array[index], type_three_array[index]}; + } + + constexpr std::array get_element_tuple_arr() { + const auto make_tuple_arr_lambda = [this](std::index_sequence) { + return std::array{get_expected_element_tuple(Indices)...}; + }; + + return make_tuple_arr_lambda(std::make_index_sequence{}); + } + + constexpr std::array get_element_tuple_arr() const { + const auto make_tuple_arr_lambda = [this](std::index_sequence) { + return std::array{get_expected_element_tuple(Indices)...}; + }; + + return make_tuple_arr_lambda(std::make_index_sequence{}); + } +}; + +template + requires(CanTestElementType) +class single_element_test_container { +private: + std::array element_array; + +public: + using element_tuple_type = std::tuple; + using const_element_tuple_type = std::tuple; + + using reference_tuple_type = std::tuple; + using const_reference_tuple_type = std::tuple; + using rvalue_reference_tuple_type = std::tuple; + using const_rvalue_reference_tuple_type = std::tuple; + + static constexpr std::size_t smallest_array_size = Size; + + constexpr single_element_test_container(const std::array element_init_arr) + : element_array(element_init_arr) {} + + constexpr auto get_element_span() { + return std::span{element_array}; + } + + constexpr auto get_element_span() const { + return std::span>{element_array}; + } + + constexpr auto& get_underlying_element_array() { + return element_array; + } + + constexpr const auto& get_underlying_element_array() const { + return element_array; + } + + constexpr reference_tuple_type get_expected_element_tuple(const std::size_t index) { + assert(index < smallest_array_size); + return reference_tuple_type{element_array[index]}; + } + + constexpr const_reference_tuple_type get_expected_element_tuple(const std::size_t index) const { + assert(index < smallest_array_size); + return const_reference_tuple_type{element_array[index]}; + } + + constexpr std::array get_element_tuple_arr() { + const auto make_tuple_arr_lambda = [this](std::index_sequence) { + return std::array{get_expected_element_tuple(Indices)...}; + }; + + return make_tuple_arr_lambda(std::make_index_sequence{}); + } + + constexpr std::array get_element_tuple_arr() const { + const auto make_tuple_arr_lambda = [this](std::index_sequence) { + return std::array{get_expected_element_tuple(Indices)...}; + }; + + return make_tuple_arr_lambda(std::make_index_sequence{}); + } +}; + +// NOTE: std::views::zip shouldn't care about whether or not the views use proxy references, +// but for our tests, we need to. +template +struct reference_type_solver { + using reference_type = const T&; +}; + +template +struct reference_type_solver> { + using reference_type = const Element&; +}; + +template +constexpr bool do_tuples_reference_same_objects(const LHSTupleType& lhs_tuple, const RHSTupleType& rhs_tuple) { + STATIC_ASSERT(std::tuple_size_v == std::tuple_size_v); + + const auto evaluate_single_element_lambda = [&lhs_tuple, &rhs_tuple]() { + using reference_type = + typename reference_type_solver>::reference_type; + return (std::addressof(static_cast(std::get(lhs_tuple))) + == std::addressof(static_cast(std::get(rhs_tuple)))); + }; + + using index_sequence_type = std::make_index_sequence>; + const auto evaluate_tuples_lambda = + [&evaluate_single_element_lambda](std::index_sequence) { + return (evaluate_single_element_lambda.template operator()() && ...); + }; + + return evaluate_tuples_lambda(index_sequence_type{}); } +template +constexpr bool test_one(TestContainerType& test_container, RangeTypes&&... ranges) { + // Ignore instances where one of the generated test ranges does not model + // std::ranges::viewable_range. + if constexpr ((std::ranges::viewable_range && ...)) { + using ZipType = std::ranges::zip_view...>; + + constexpr bool are_views = + (std::ranges::view> && ...) && (sizeof...(RangeTypes) > 0); + + STATIC_ASSERT(std::ranges::view); + STATIC_ASSERT(std::ranges::input_range); + STATIC_ASSERT(std::ranges::forward_range == (std::ranges::forward_range && ...)); + STATIC_ASSERT( + std::ranges::bidirectional_range == (std::ranges::bidirectional_range && ...)); + STATIC_ASSERT( + std::ranges::random_access_range == (std::ranges::random_access_range && ...)); + STATIC_ASSERT( + std::ranges::common_range< + ZipType> == (sizeof...(RangeTypes) == 1 && (std::ranges::common_range && ...)) + || (!(std::ranges::bidirectional_range && ...) + && (std::ranges::common_range && ...)) + || ((std::ranges::random_access_range && ...) + && (std::ranges::sized_range && ...))); + + // Validate conditional default-initializability + STATIC_ASSERT( + std::is_default_constructible_v == (std::is_default_constructible_v> && ...)); + + // Validate conditional borrowed_range + STATIC_ASSERT( + std::ranges::borrowed_range == (std::ranges::borrowed_range> && ...)); + + // Validate range adaptor object + + // ... with lvalue arguments + STATIC_ASSERT( + CanViewZip == (!are_views || (std::copy_constructible> && ...))); + if constexpr (CanViewZip) { + using ExpectedZipType = ZipType; + constexpr bool is_noexcept = (std::is_nothrow_copy_constructible_v> && ...); + + STATIC_ASSERT(std::same_as); + STATIC_ASSERT(noexcept(std::views::zip(ranges...)) == is_noexcept); + } + + // ... with const lvalue arguments + STATIC_ASSERT(CanViewZip&...> == (!are_views || (std::copy_constructible> && ...))); + if constexpr (CanViewZip&...>) { + using ExpectedZipType = std::ranges::zip_view&>...>; + constexpr bool is_noexcept = (std::is_nothrow_copy_constructible_v> && ...); + + STATIC_ASSERT(std::same_as); + STATIC_ASSERT(noexcept(std::views::zip(std::as_const(ranges)...)) == is_noexcept); + } + + // ... with rvalue argument + STATIC_ASSERT(CanViewZip...> == (are_views || (std::movable> && ...))); + if constexpr (CanViewZip...>) { + using ExpectedZipType = std::ranges::zip_view>...>; + constexpr bool is_noexcept = (std::is_nothrow_move_constructible_v> && ...); + + STATIC_ASSERT(std::same_as); + STATIC_ASSERT(noexcept(std::views::zip(std::move(ranges)...)) == is_noexcept); + } + + // ... with const rvalue argument + STATIC_ASSERT(CanViewZip...> == (are_views && (std::copy_constructible> && ...))); + if constexpr (CanViewZip...>) { + using ExpectedZipType = std::ranges::zip_view>...>; + constexpr bool is_noexcept = (std::is_nothrow_copy_constructible_v> && ...); + + STATIC_ASSERT( + std::same_as); + STATIC_ASSERT(noexcept(std::views::zip(std::move(std::as_const(ranges))...)) == is_noexcept); + } + + // Validate deduction guide + std::same_as auto zipped_range = std::ranges::zip_view{std::forward(ranges)...}; + const auto tuple_element_arr = test_container.get_element_tuple_arr(); + const auto const_tuple_element_arr = std::as_const(test_container).get_element_tuple_arr(); + + // Validate zip_view::size() + STATIC_ASSERT(CanMemberSize == (std::ranges::sized_range> && ...)); + if constexpr (CanMemberSize) { + using expected_size_type = std::_Make_unsigned_like_t< + std::common_type_t>()))...>>; + std::same_as auto zip_size = zipped_range.size(); + + assert(zip_size == std::ranges::size(tuple_element_arr)); + STATIC_ASSERT(noexcept(zipped_range.size()) + == noexcept(std::ranges::min( + {static_cast(std::declval>().size())...}))); + } + + STATIC_ASSERT(CanMemberSize == (std::ranges::sized_range> && ...)); + if constexpr (CanMemberSize) { + using expected_size_type = std::_Make_unsigned_like_t< + std::common_type_t>()))...>>; + std::same_as auto zip_size = zipped_range.size(); + + assert(zip_size == std::ranges::size(tuple_element_arr)); + STATIC_ASSERT(noexcept(std::as_const(zipped_range).size()) + == noexcept(std::ranges::min( + {static_cast(std::declval>().size())...}))); + } + + const bool is_empty = std::ranges::empty(tuple_element_arr); + + // Validate view_interface::empty() and view_interface::operator bool() + // + // From here on out, we'll be re-using concepts which we already verified to reduce + // redundancy. + STATIC_ASSERT( + CanMemberEmpty == (std::ranges::sized_range || std::ranges::forward_range) ); + if constexpr (CanMemberEmpty) { + assert(zipped_range.empty() == is_empty); + } + + STATIC_ASSERT( + CanMemberEmpty< + const ZipType> == (std::ranges::sized_range || std::ranges::forward_range) ); + if constexpr (CanMemberEmpty) { + assert(std::as_const(zipped_range).empty() == is_empty); + } + + STATIC_ASSERT(CanBool == CanMemberEmpty); + if constexpr (CanBool) { + assert(static_cast(zipped_range) != is_empty); + } + + STATIC_ASSERT(CanBool == CanMemberEmpty); + if constexpr (CanBool) { + assert(static_cast(std::as_const(zipped_range)) != is_empty); + } + + // Validate contents of zipped range + assert(std::ranges::equal(zipped_range, tuple_element_arr, [](const auto& lhs_tuple, const auto& rhs_tuple) { + return do_tuples_reference_same_objects(lhs_tuple, rhs_tuple); + })); + +#pragma warning(push) +#pragma warning(disable : 4127) + if (!(std::ranges::forward_range> && ...)) // intentionally not if constexpr + { + return true; + } +#pragma warning(pop) + + // Validate view_interface::data() + // + // This should never exist because zip_view's iterator never models contiguous_iterator. + STATIC_ASSERT(!std::contiguous_iterator>); + STATIC_ASSERT(!CanMemberData); + STATIC_ASSERT(!std::contiguous_iterator>); + STATIC_ASSERT(!CanMemberData); + + // Validate view_interface::operator[] + STATIC_ASSERT(CanIndex == std::ranges::random_access_range); + if constexpr (CanIndex) { + assert(do_tuples_reference_same_objects(zipped_range[0], tuple_element_arr[0])); + } + + STATIC_ASSERT(CanIndex == std::ranges::random_access_range); + if constexpr (CanIndex) { + assert(do_tuples_reference_same_objects(std::as_const(zipped_range)[0], tuple_element_arr[0])); + } + + // Validate view_interface::front() + STATIC_ASSERT(CanMemberFront == std::ranges::forward_range); + if constexpr (CanMemberFront) { + assert(do_tuples_reference_same_objects(zipped_range.front(), tuple_element_arr[0])); + } + + STATIC_ASSERT(CanMemberFront == std::ranges::forward_range); + if constexpr (CanMemberFront) { + assert(do_tuples_reference_same_objects(std::as_const(zipped_range).front(), const_tuple_element_arr[0])); + } + + // Validate view_interface::back() + STATIC_ASSERT( + CanMemberBack< + ZipType> == (std::ranges::bidirectional_range && std::ranges::common_range) ); + if constexpr (CanMemberBack) { + assert(do_tuples_reference_same_objects( + zipped_range.back(), tuple_element_arr[TestContainerType::smallest_array_size - 1])); + } + + STATIC_ASSERT( + CanMemberBack< + const ZipType> == (std::ranges::bidirectional_range && std::ranges::common_range) ); + if constexpr (CanMemberBack) { + assert(do_tuples_reference_same_objects(std::as_const(zipped_range).back(), + const_tuple_element_arr[TestContainerType::smallest_array_size - 1])); + } + + // Validate zip_view::begin() + STATIC_ASSERT(CanMemberBegin); + { + const std::same_as> auto itr = zipped_range.begin(); + assert(do_tuples_reference_same_objects(*itr, tuple_element_arr[0])); + } + + STATIC_ASSERT(CanMemberBegin == (std::ranges::range> && ...)); + if constexpr (CanMemberBegin) { + assert( + do_tuples_reference_same_objects(*(std::as_const(zipped_range).begin()), const_tuple_element_arr[0])); + } + + // Validate zip_view::end() + STATIC_ASSERT(CanMemberEnd); + if constexpr (std::equality_comparable>) { + auto end = zipped_range.begin(); + std::ranges::advance(end, TestContainerType::smallest_array_size); + + assert(end == zipped_range.end()); + } + + STATIC_ASSERT(CanMemberEnd == (std::ranges::range> && ...)); + if constexpr (CanMemberEnd && std::equality_comparable>) { + auto end = std::as_const(zipped_range).begin(); + std::ranges::advance(end, TestContainerType::smallest_array_size); + + assert(end == std::as_const(zipped_range).end()); + } + + const auto validate_iterators_lambda = []( + LocalZipType& relevant_range, + const ArrayType& relevant_tuple_element_arr) { + constexpr bool is_const = std::same_as>; + + STATIC_ASSERT( + std::is_default_constructible_v> == (std::is_default_constructible_v> && ...)); + + std::same_as> auto itr = relevant_range.begin(); + + // Validate iterator operator overloads + if constexpr (std::ranges::forward_range) { + assert(do_tuples_reference_same_objects(*itr++, relevant_tuple_element_arr[0])); + } else { + // If LocalZipType does not model forward_range, we can still use post-fix operator + // which returns void. + itr++; + } + + assert(do_tuples_reference_same_objects(*++itr, relevant_tuple_element_arr[2])); + + if constexpr (std::ranges::bidirectional_range) { + assert(do_tuples_reference_same_objects(*itr--, relevant_tuple_element_arr[2])); + assert(do_tuples_reference_same_objects(*--itr, relevant_tuple_element_arr[0])); + } + + if constexpr (std::ranges::random_access_range) { + itr += 2; + assert(do_tuples_reference_same_objects(*itr, relevant_tuple_element_arr[2])); + + itr -= 2; + assert(do_tuples_reference_same_objects(*itr, relevant_tuple_element_arr[0])); + + assert(do_tuples_reference_same_objects(itr[2], relevant_tuple_element_arr[2])); + + const std::same_as> auto itr2 = (itr + 2); + assert(do_tuples_reference_same_objects(*itr2, relevant_tuple_element_arr[2])); + + const std::same_as> auto itr3 = (2 + itr); + assert(do_tuples_reference_same_objects(*itr3, relevant_tuple_element_arr[2])); + + const std::same_as> auto itr4 = itr3 - 2; + assert(do_tuples_reference_same_objects(*itr4, relevant_tuple_element_arr[0])); + + using iterator_difference_type = + std::common_type_t...>; + + const std::same_as auto diff1 = (itr2 - itr); + assert(diff1 == static_cast(2)); + + const std::same_as auto diff2 = (itr - itr2); + assert(diff2 == static_cast(-2)); + + if constexpr ((std::equality_comparable> && ...)) { + assert(itr == itr4); + assert(itr != itr2); + } + + // Per LWG-3692: The only constraint placed on operator<=> for zip_view's iterator is that + // (std::ranges::random_access_range) is satisfied. We need no additional checks. + using three_way_ordering_category = decltype(itr <=> itr2); + + assert(itr <=> itr4 == three_way_ordering_category::equivalent); + assert(itr <=> itr2 == three_way_ordering_category::less); + assert(itr2 <=> itr == three_way_ordering_category::greater); + } + + // Validate [ADL::]iter_move() + if constexpr (is_const) { + STATIC_ASSERT(std::is_same_v>>()))...>>); + } else { + STATIC_ASSERT(std::is_same_v>>()))...>>); + } + + STATIC_ASSERT(noexcept(iter_move(itr)) + == (noexcept(std::ranges::iter_move( + std::declval&>())) + && ...) + && (std::is_nothrow_move_constructible_v< + std::ranges::range_rvalue_reference_t> && ...)); + + assert(do_tuples_reference_same_objects(*itr, iter_move(itr))); + + // Validate [ADL::]iter_swap() + if constexpr ((std::indirectly_swappable> && ...)) { + const typename TestContainerType::element_tuple_type old_itr_value = *itr; + + std::same_as> auto itr2 = itr; + itr2++; + + const typename TestContainerType::element_tuple_type old_itr2_value = *itr2; + + iter_swap(itr, itr2); + + assert(*itr == old_itr2_value); + assert(*itr2 == old_itr_value); + + // We can't test iter_swap()'s noexcept specifier without access to the member variables + // of the iterator. + } + + // Validate sentinels + if constexpr (!std::ranges::common_range) { + STATIC_ASSERT( + std::is_default_constructible_v> == (std::is_default_constructible_v> && ...)); + + const std::same_as> auto itr2 = relevant_range.begin(); + const std::same_as> auto sen = relevant_range.end(); + + if constexpr ((std::sentinel_for, + std::ranges::iterator_t> && ...)) { + auto advanced_itr = relevant_range.begin(); + std::ranges::advance(advanced_itr, TestContainerType::smallest_array_size); + + assert(advanced_itr == sen); + assert(itr2 != sen); + } + + if constexpr ((std::sized_sentinel_for, + std::ranges::iterator_t> && ...)) { + using difference_type = std::common_type_t...>; + + const std::same_as auto diff1 = (itr2 - sen); + const std::same_as auto diff2 = (sen - itr2); + + if constexpr (std::is_arithmetic_v) { + assert(diff1 == -(static_cast(TestContainerType::smallest_array_size))); + assert(diff2 == static_cast(TestContainerType::smallest_array_size)); + } else if constexpr (std::constructible_from) { + assert(diff1 == -difference_type{TestContainerType::smallest_array_size}); + assert(diff2 == difference_type{TestContainerType::smallest_array_size}); + } + } + } + }; + + // Validate iterators and sentinels + if constexpr (CanMemberBegin && CanMemberEnd) { + validate_iterators_lambda.template operator()...>( + zipped_range, tuple_element_arr); + } + + if constexpr (CanMemberBegin && CanMemberEnd) { + validate_iterators_lambda + .template operator()...>( + std::as_const(zipped_range), const_tuple_element_arr); + } + } + + return true; +} + +// zip_view is sensitive to the following: +// +// - The categories of RangeTypes... +// - Whether or not differencing for RangeTypes... is valid; in C++, +// (std::sized_sentinel_for, std::ranges::iterator_t> && ...) +// - The commonality of RangeTypes... +// - Whether or not (std::sentinel_for, std::ranges::iterator_t> && +// ...) +// is true +// - Whether or not the size() member exists for each of RangeTypes..., as it is used by std::ranges::size() +// - The sizeof...(RangeTypes) +// +// Other conditions are irrelevant: +// +// - The type of std::ranges::range_reference_t for any RangeTypes... is not considered +// - The raw types of RangeTypes... need not fulfill the view concept because std::views::all_t... is +// used instead, which does satisfy the view concept + +template +using test_range = test::range || to_bool(IsCommon) ? test::CanCompare::yes : Eq)>; + +constexpr std::array default_int_array{0, 1, 2, 3, 4, 5, 6}; + +constexpr single_element_test_container single_element_container_instance{default_int_array}; +constexpr three_element_test_container three_element_container_instance{default_int_array, + std::array{0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f}, std::array{'a', 'b', 'c', 'd', 'e'}}; + +// The typical instantiator struct isn't templated like this, so that it could then be used with the +// existing testing machinery defined in range_algorithm_support.hpp. We can't use that stuff here, +// however, because std::views::zip takes multiple template parameters. +// +// The idea here might be useful for other view types which take multiple range parameters. Feel +// free to move something similar into range_algorithm_support.hpp if you feel that this could be +// used in another test suite. + +template +struct range_type_solver { +protected: + template + using range_type = test_range; +}; + +template <> +struct range_type_solver { +protected: + template + using range_type = test::range || to_bool(IsCommon) ? test::CanCompare::yes : Eq), + test::ProxyRef{!std::derived_from}, test::CanView::yes, + test::Copyability::move_only>; +}; + +template +struct instantiator_impl : private range_type_solver { +private: + template + using range_type = typename range_type_solver::template range_type; + + template + struct first_type_solver {}; + + template + struct first_type_solver { + using first_type = FirstType; + }; + + using standard_range_tuple_type = std::tuple, + range_type, + range_type>; + + using differing_category_range_type = range_type; + using differing_size_member_range_type = range_type; + using differing_sentinel_for_range_type = range_type; + using differing_is_common_range_type = range_type; + using differing_can_compare_range_tupe = range_type; + +public: + static constexpr void call() { + const auto test_instances_lambda = [](std::index_sequence) { + // NOTE: We intentionally create lots of ranges here so that we do not have to worry about + // making multiple calls to std::views::zip::begin() for input iterators. + + // Test the single-range use of std::views::zip (i.e., sizeof...(RangeTypes) == 1). + auto single_range = std::tuple_element_t<0, standard_range_tuple_type>{ + single_element_container_instance.get_element_span()}; + test_one(single_element_container_instance, single_range); + + /* + // Test three ranges with std::views::zip with... + + // all of their traits being the same,... + { + auto first_range = std::tuple_element_t<0, standard_range_tuple_type>{ + three_element_container_instance.get_element_span<0>()}; + auto second_range = std::tuple_element_t<1, standard_range_tuple_type>{ + three_element_container_instance.get_element_span<1>()}; + auto third_range = std::tuple_element_t<2, standard_range_tuple_type>{ + three_element_container_instance.get_element_span<2>()}; + + test_one(three_element_container_instance, first_range, second_range, third_range); + } + + // one range having a different category,... + if constexpr (!std::is_same_v) { + auto differing_category_range = + differing_category_range_type{three_element_container_instance.get_element_span<0>()}; + auto second_range = std::tuple_element_t<1, standard_range_tuple_type>{ + three_element_container_instance.get_element_span<1>()}; + auto third_range = std::tuple_element_t<2, standard_range_tuple_type>{ + three_element_container_instance.get_element_span<2>()}; + + test_one(three_element_container_instance, differing_category_range, second_range, third_range); + } + + // one range having a different path for std::ranges::size(),... + { + auto differing_size_member_range = + differing_size_member_range_type{three_element_container_instance.get_element_span<0>()}; + auto second_range = std::tuple_element_t<1, standard_range_tuple_type>{ + three_element_container_instance.get_element_span<1>()}; + auto third_range = std::tuple_element_t<2, standard_range_tuple_type>{ + three_element_container_instance.get_element_span<2>()}; + + test_one(three_element_container_instance, differing_size_member_range, second_range, third_range); + } + + // one range having a different std::sized_sentinel_for value,... + { + auto differing_sentinel_for_range = + differing_sentinel_for_range_type{three_element_container_instance.get_element_span<0>()}; + auto second_range = std::tuple_element_t<1, standard_range_tuple_type>{ + three_element_container_instance.get_element_span<1>()}; + auto third_range = std::tuple_element_t<2, standard_range_tuple_type>{ + three_element_container_instance.get_element_span<2>()}; + + test_one(three_element_container_instance, differing_sentinel_for_range, second_range, third_range); + } + + // one range having a different commonality,... + { + auto differing_is_common_range = + differing_is_common_range_type{three_element_container_instance.get_element_span<0>()}; + auto second_range = std::tuple_element_t<1, standard_range_tuple_type>{ + three_element_container_instance.get_element_span<1>()}; + auto third_range = std::tuple_element_t<2, standard_range_tuple_type>{ + three_element_container_instance.get_element_span<2>()}; + + test_one(three_element_container_instance, differing_is_common_range, second_range, third_range); + } + + // and one range having a different iterator/sentinel type equality. + { + auto differing_can_compare_range = + differing_can_compare_range_tupe{three_element_container_instance.get_element_span<0>()}; + auto second_range = std::tuple_element_t<1, standard_range_tuple_type>{ + three_element_container_instance.get_element_span<1>()}; + auto third_range = std::tuple_element_t<2, standard_range_tuple_type>{ + three_element_container_instance.get_element_span<2>()}; + + test_one(three_element_container_instance, differing_can_compare_range, second_range, third_range); + } + */ + }; + + test_instances_lambda(std::make_index_sequence<3>{}); + } +}; + +template +struct instantiator : public instantiator_impl {}; + +template +struct move_only_view_instantiator : public instantiator_impl {}; + +template class InstantiatorType> +constexpr bool instantiation_test_for_category() { + // Unlike previous tested range/view types, std::views::zip takes an unbounded parameter pack of ranges, so + // we cannot test every possible combination of sensitive inputs. However, every evaluated condition + // other than sizeof... is evaluated as (Condition && ...); so, if one condition fails, then the entire + // constraint should fail to be met. + + using test::Sized, test::CanDifference, test::Common, test::CanCompare; + + InstantiatorType::call(); + /* + InstantiatorType::call(); + InstantiatorType::call(); + InstantiatorType::call(); + InstantiatorType::call(); + InstantiatorType::call(); + InstantiatorType::call(); + InstantiatorType::call(); + InstantiatorType::call(); + InstantiatorType::call(); + InstantiatorType::call(); + InstantiatorType::call(); + InstantiatorType::call(); + InstantiatorType::call(); + InstantiatorType::call(); + InstantiatorType::call(); + */ + + return true; +} + +template