358 lines · c
1// -*- C++ -*-2//===----------------------------------------------------------------------===//3//4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.5// See https://llvm.org/LICENSE.txt for license information.6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception7//8//===----------------------------------------------------------------------===//9 10#ifndef _LIBCPP___RANGES_ZIP_TRANSFORM_VIEW_H11#define _LIBCPP___RANGES_ZIP_TRANSFORM_VIEW_H12 13#include <__config>14 15#include <__concepts/constructible.h>16#include <__concepts/convertible_to.h>17#include <__concepts/derived_from.h>18#include <__concepts/equality_comparable.h>19#include <__concepts/invocable.h>20#include <__functional/invoke.h>21#include <__iterator/concepts.h>22#include <__iterator/incrementable_traits.h>23#include <__iterator/iterator_traits.h>24#include <__memory/addressof.h>25#include <__ranges/access.h>26#include <__ranges/all.h>27#include <__ranges/concepts.h>28#include <__ranges/empty_view.h>29#include <__ranges/movable_box.h>30#include <__ranges/view_interface.h>31#include <__ranges/zip_view.h>32#include <__type_traits/decay.h>33#include <__type_traits/invoke.h>34#include <__type_traits/is_object.h>35#include <__type_traits/is_reference.h>36#include <__type_traits/is_referenceable.h>37#include <__type_traits/maybe_const.h>38#include <__type_traits/remove_cvref.h>39#include <__utility/forward.h>40#include <__utility/in_place.h>41#include <__utility/move.h>42#include <tuple> // for std::apply43 44#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)45# pragma GCC system_header46#endif47 48_LIBCPP_PUSH_MACROS49#include <__undef_macros>50_LIBCPP_BEGIN_NAMESPACE_STD51 52#if _LIBCPP_STD_VER >= 2353 54namespace ranges {55 56template <move_constructible _Fn, input_range... _Views>57 requires(view<_Views> && ...) &&58 (sizeof...(_Views) > 0) && is_object_v<_Fn> && regular_invocable<_Fn&, range_reference_t<_Views>...> &&59 __referenceable<invoke_result_t<_Fn&, range_reference_t<_Views>...>>60class zip_transform_view : public view_interface<zip_transform_view<_Fn, _Views...>> {61 _LIBCPP_NO_UNIQUE_ADDRESS zip_view<_Views...> __zip_;62 _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Fn> __fun_;63 64 using _InnerView _LIBCPP_NODEBUG = zip_view<_Views...>;65 template <bool _Const>66 using __ziperator _LIBCPP_NODEBUG = iterator_t<__maybe_const<_Const, _InnerView>>;67 template <bool _Const>68 using __zentinel _LIBCPP_NODEBUG = sentinel_t<__maybe_const<_Const, _InnerView>>;69 70 template <bool>71 class __iterator;72 73 template <bool>74 class __sentinel;75 76public:77 _LIBCPP_HIDE_FROM_ABI zip_transform_view() = default;78 79 _LIBCPP_HIDE_FROM_ABI constexpr explicit zip_transform_view(_Fn __fun, _Views... __views)80 : __zip_(std::move(__views)...), __fun_(in_place, std::move(__fun)) {}81 82 _LIBCPP_HIDE_FROM_ABI constexpr auto begin() { return __iterator<false>(*this, __zip_.begin()); }83 84 _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const85 requires range<const _InnerView> && regular_invocable<const _Fn&, range_reference_t<const _Views>...>86 {87 return __iterator<true>(*this, __zip_.begin());88 }89 90 _LIBCPP_HIDE_FROM_ABI constexpr auto end() {91 if constexpr (common_range<_InnerView>) {92 return __iterator<false>(*this, __zip_.end());93 } else {94 return __sentinel<false>(__zip_.end());95 }96 }97 98 _LIBCPP_HIDE_FROM_ABI constexpr auto end() const99 requires range<const _InnerView> && regular_invocable<const _Fn&, range_reference_t<const _Views>...>100 {101 if constexpr (common_range<const _InnerView>) {102 return __iterator<true>(*this, __zip_.end());103 } else {104 return __sentinel<true>(__zip_.end());105 }106 }107 108 _LIBCPP_HIDE_FROM_ABI constexpr auto size()109 requires sized_range<_InnerView>110 {111 return __zip_.size();112 }113 114 _LIBCPP_HIDE_FROM_ABI constexpr auto size() const115 requires sized_range<const _InnerView>116 {117 return __zip_.size();118 }119};120 121template <class _Fn, class... _Ranges>122zip_transform_view(_Fn, _Ranges&&...) -> zip_transform_view<_Fn, views::all_t<_Ranges>...>;123 124template <bool _Const, class _Fn, class... _Views>125struct __zip_transform_iterator_category_base {};126 127template <bool _Const, class _Fn, class... _Views>128 requires forward_range<__maybe_const<_Const, zip_view<_Views...>>>129struct __zip_transform_iterator_category_base<_Const, _Fn, _Views...> {130private:131 template <class _View>132 using __tag _LIBCPP_NODEBUG = typename iterator_traits<iterator_t<__maybe_const<_Const, _View>>>::iterator_category;133 134 static consteval auto __get_iterator_category() {135 if constexpr (!is_reference_v<invoke_result_t<__maybe_const<_Const, _Fn>&,136 range_reference_t<__maybe_const<_Const, _Views>>...>>) {137 return input_iterator_tag();138 } else if constexpr ((derived_from<__tag<_Views>, random_access_iterator_tag> && ...)) {139 return random_access_iterator_tag();140 } else if constexpr ((derived_from<__tag<_Views>, bidirectional_iterator_tag> && ...)) {141 return bidirectional_iterator_tag();142 } else if constexpr ((derived_from<__tag<_Views>, forward_iterator_tag> && ...)) {143 return forward_iterator_tag();144 } else {145 return input_iterator_tag();146 }147 }148 149public:150 using iterator_category = decltype(__get_iterator_category());151};152 153template <move_constructible _Fn, input_range... _Views>154 requires(view<_Views> && ...) &&155 (sizeof...(_Views) > 0) && is_object_v<_Fn> && regular_invocable<_Fn&, range_reference_t<_Views>...> &&156 __referenceable<invoke_result_t<_Fn&, range_reference_t<_Views>...>>157template <bool _Const>158class zip_transform_view<_Fn, _Views...>::__iterator159 : public __zip_transform_iterator_category_base<_Const, _Fn, _Views...> {160 using _Parent _LIBCPP_NODEBUG = __maybe_const<_Const, zip_transform_view>;161 using _Base _LIBCPP_NODEBUG = __maybe_const<_Const, _InnerView>;162 163 friend zip_transform_view<_Fn, _Views...>;164 165 _Parent* __parent_ = nullptr;166 __ziperator<_Const> __inner_;167 168 _LIBCPP_HIDE_FROM_ABI constexpr __iterator(_Parent& __parent, __ziperator<_Const> __inner)169 : __parent_(std::addressof(__parent)), __inner_(std::move(__inner)) {}170 171 _LIBCPP_HIDE_FROM_ABI constexpr auto __get_deref_and_invoke() const noexcept {172 return [&__fun = *__parent_->__fun_](const auto&... __iters) noexcept(noexcept(std::invoke(173 *__parent_->__fun_, *__iters...))) -> decltype(auto) { return std::invoke(__fun, *__iters...); };174 }175 176public:177 using iterator_concept = typename __ziperator<_Const>::iterator_concept;178 using value_type =179 remove_cvref_t<invoke_result_t<__maybe_const<_Const, _Fn>&, range_reference_t<__maybe_const<_Const, _Views>>...>>;180 using difference_type = range_difference_t<_Base>;181 182 _LIBCPP_HIDE_FROM_ABI __iterator() = default;183 _LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)184 requires _Const && convertible_to<__ziperator<false>, __ziperator<_Const>>185 : __parent_(__i.__parent_), __inner_(std::move(__i.__inner_)) {}186 187 _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const188 noexcept(noexcept(std::apply(__get_deref_and_invoke(), __zip_view_iterator_access::__get_underlying(__inner_)))) {189 return std::apply(__get_deref_and_invoke(), __zip_view_iterator_access::__get_underlying(__inner_));190 }191 192 _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {193 ++__inner_;194 return *this;195 }196 197 _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++*this; }198 199 _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)200 requires forward_range<_Base>201 {202 auto __tmp = *this;203 ++*this;204 return __tmp;205 }206 207 _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()208 requires bidirectional_range<_Base>209 {210 --__inner_;211 return *this;212 }213 214 _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)215 requires bidirectional_range<_Base>216 {217 auto __tmp = *this;218 --*this;219 return __tmp;220 }221 222 _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __x)223 requires random_access_range<_Base>224 {225 __inner_ += __x;226 return *this;227 }228 229 _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __x)230 requires random_access_range<_Base>231 {232 __inner_ -= __x;233 return *this;234 }235 236 _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](difference_type __n) const237 requires random_access_range<_Base>238 {239 return std::apply(240 [&]<class... _Is>(const _Is&... __iters) -> decltype(auto) {241 return std::invoke(*__parent_->__fun_, __iters[iter_difference_t<_Is>(__n)]...);242 },243 __zip_view_iterator_access::__get_underlying(__inner_));244 }245 246 _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)247 requires equality_comparable<__ziperator<_Const>>248 {249 return __x.__inner_ == __y.__inner_;250 }251 252 _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)253 requires random_access_range<_Base>254 {255 return __x.__inner_ <=> __y.__inner_;256 }257 258 _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(const __iterator& __i, difference_type __n)259 requires random_access_range<_Base>260 {261 return __iterator(*__i.__parent_, __i.__inner_ + __n);262 }263 264 _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, const __iterator& __i)265 requires random_access_range<_Base>266 {267 return __iterator(*__i.__parent_, __i.__inner_ + __n);268 }269 270 _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(const __iterator& __i, difference_type __n)271 requires random_access_range<_Base>272 {273 return __iterator(*__i.__parent_, __i.__inner_ - __n);274 }275 276 _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)277 requires sized_sentinel_for<__ziperator<_Const>, __ziperator<_Const>>278 {279 return __x.__inner_ - __y.__inner_;280 }281};282 283template <move_constructible _Fn, input_range... _Views>284 requires(view<_Views> && ...) &&285 (sizeof...(_Views) > 0) && is_object_v<_Fn> && regular_invocable<_Fn&, range_reference_t<_Views>...> &&286 __referenceable<invoke_result_t<_Fn&, range_reference_t<_Views>...>>287template <bool _Const>288class zip_transform_view<_Fn, _Views...>::__sentinel {289 __zentinel<_Const> __inner_;290 291 friend zip_transform_view<_Fn, _Views...>;292 293 _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(__zentinel<_Const> __inner) : __inner_(__inner) {}294 295public:296 _LIBCPP_HIDE_FROM_ABI __sentinel() = default;297 298 _LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __i)299 requires _Const && convertible_to<__zentinel<false>, __zentinel<_Const>>300 : __inner_(__i.__inner_) {}301 302 template <bool _OtherConst>303 requires sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>304 _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {305 return __x.__inner_ == __y.__inner_;306 }307 308 template <bool _OtherConst>309 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>310 _LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _InnerView>>311 operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {312 return __x.__inner_ - __y.__inner_;313 }314 315 template <bool _OtherConst>316 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>317 _LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _InnerView>>318 operator-(const __sentinel& __x, const __iterator<_OtherConst>& __y) {319 return __x.__inner_ - __y.__inner_;320 }321};322 323namespace views {324namespace __zip_transform {325 326struct __fn {327 template <class _Fn>328 requires(move_constructible<decay_t<_Fn>> && regular_invocable<decay_t<_Fn>&> &&329 is_object_v<invoke_result_t<decay_t<_Fn>&>>)330 _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Fn&&) const331 noexcept(noexcept(auto(views::empty<decay_t<invoke_result_t<decay_t<_Fn>&>>>))) {332 return views::empty<decay_t<invoke_result_t<decay_t<_Fn>&>>>;333 }334 335 template <class _Fn, class... _Ranges>336 requires(sizeof...(_Ranges) > 0)337 _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Fn&& __fun, _Ranges&&... __rs) const338 noexcept(noexcept(zip_transform_view(std::forward<_Fn>(__fun), std::forward<_Ranges>(__rs)...)))339 -> decltype(zip_transform_view(std::forward<_Fn>(__fun), std::forward<_Ranges>(__rs)...)) {340 return zip_transform_view(std::forward<_Fn>(__fun), std::forward<_Ranges>(__rs)...);341 }342};343 344} // namespace __zip_transform345inline namespace __cpo {346inline constexpr auto zip_transform = __zip_transform::__fn{};347} // namespace __cpo348} // namespace views349} // namespace ranges350 351#endif // _LIBCPP_STD_VER >= 23352 353_LIBCPP_END_NAMESPACE_STD354 355_LIBCPP_POP_MACROS356 357#endif // _LIBCPP___RANGES_ZIP_TRANSFORM_VIEW_H358