__cxx03/__ranges/take_view.h

0001 // -*- C++ -*-
0002 //===----------------------------------------------------------------------===//
0003 //
0004 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0005 // See https://llvm.org/LICENSE.txt for license information.
0006 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0007 //
0008 //===----------------------------------------------------------------------===//
0009
0010 #ifndef _LIBCPP___CXX03___RANGES_TAKE_VIEW_H
0011 #define _LIBCPP___CXX03___RANGES_TAKE_VIEW_H
0012
0013 #include <__cxx03/__algorithm/min.h>
0014 #include <__cxx03/__algorithm/ranges_min.h>
0015 #include <__cxx03/__assert>
0016 #include <__cxx03/__concepts/constructible.h>
0017 #include <__cxx03/__concepts/convertible_to.h>
0018 #include <__cxx03/__config>
0019 #include <__cxx03/__functional/bind_back.h>
0020 #include <__cxx03/__fwd/span.h>
0021 #include <__cxx03/__fwd/string_view.h>
0022 #include <__cxx03/__iterator/concepts.h>
0023 #include <__cxx03/__iterator/counted_iterator.h>
0024 #include <__cxx03/__iterator/default_sentinel.h>
0025 #include <__cxx03/__iterator/distance.h>
0026 #include <__cxx03/__iterator/iterator_traits.h>
0027 #include <__cxx03/__ranges/access.h>
0028 #include <__cxx03/__ranges/all.h>
0029 #include <__cxx03/__ranges/concepts.h>
0030 #include <__cxx03/__ranges/empty_view.h>
0031 #include <__cxx03/__ranges/enable_borrowed_range.h>
0032 #include <__cxx03/__ranges/iota_view.h>
0033 #include <__cxx03/__ranges/range_adaptor.h>
0034 #include <__cxx03/__ranges/repeat_view.h>
0035 #include <__cxx03/__ranges/size.h>
0036 #include <__cxx03/__ranges/subrange.h>
0037 #include <__cxx03/__ranges/view_interface.h>
0038 #include <__cxx03/__type_traits/decay.h>
0039 #include <__cxx03/__type_traits/is_nothrow_constructible.h>
0040 #include <__cxx03/__type_traits/maybe_const.h>
0041 #include <__cxx03/__type_traits/remove_cvref.h>
0042 #include <__cxx03/__utility/auto_cast.h>
0043 #include <__cxx03/__utility/forward.h>
0044 #include <__cxx03/__utility/move.h>
0045 #include <__cxx03/cstddef>
0046
0047 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
0048 #  pragma GCC system_header
0049 #endif
0050
0051 _LIBCPP_PUSH_MACROS
0052 #include <__cxx03/__undef_macros>
0053
0054 _LIBCPP_BEGIN_NAMESPACE_STD
0055
0056 #if _LIBCPP_STD_VER >= 20
0057
0058 namespace ranges {
0059
0060 template <view _View>
0061 class take_view : public view_interface<take_view<_View>> {
0062   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
0063   range_difference_t<_View> __count_      = 0;
0064
0065   template <bool>
0066   class __sentinel;
0067
0068 public:
0069   _LIBCPP_HIDE_FROM_ABI take_view()
0070     requires default_initializable<_View>
0071   = default;
0072
0073   _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23
0074   take_view(_View __base, range_difference_t<_View> __count)
0075       : __base_(std::move(__base)), __count_(__count) {
0076     _LIBCPP_ASSERT_UNCATEGORIZED(__count >= 0, "count has to be greater than or equal to zero");
0077   }
0078
0079   _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
0080     requires copy_constructible<_View>
0081   {
0082     return __base_;
0083   }
0084
0085   _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
0086
0087   _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
0088     requires(!__simple_view<_View>)
0089   {
0090     if constexpr (sized_range<_View>) {
0091       if constexpr (random_access_range<_View>) {
0092         return ranges::begin(__base_);
0093       } else {
0094         using _DifferenceT = range_difference_t<_View>;
0095         auto __size        = size();
0096         return counted_iterator(ranges::begin(__base_), static_cast<_DifferenceT>(__size));
0097       }
0098     } else {
0099       return counted_iterator(ranges::begin(__base_), __count_);
0100     }
0101   }
0102
0103   _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
0104     requires range<const _View>
0105   {
0106     if constexpr (sized_range<const _View>) {
0107       if constexpr (random_access_range<const _View>) {
0108         return ranges::begin(__base_);
0109       } else {
0110         using _DifferenceT = range_difference_t<const _View>;
0111         auto __size        = size();
0112         return counted_iterator(ranges::begin(__base_), static_cast<_DifferenceT>(__size));
0113       }
0114     } else {
0115       return counted_iterator(ranges::begin(__base_), __count_);
0116     }
0117   }
0118
0119   _LIBCPP_HIDE_FROM_ABI constexpr auto end()
0120     requires(!__simple_view<_View>)
0121   {
0122     if constexpr (sized_range<_View>) {
0123       if constexpr (random_access_range<_View>) {
0124         return ranges::begin(__base_) + size();
0125       } else {
0126         return default_sentinel;
0127       }
0128     } else {
0129       return __sentinel<false>{ranges::end(__base_)};
0130     }
0131   }
0132
0133   _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
0134     requires range<const _View>
0135   {
0136     if constexpr (sized_range<const _View>) {
0137       if constexpr (random_access_range<const _View>) {
0138         return ranges::begin(__base_) + size();
0139       } else {
0140         return default_sentinel;
0141       }
0142     } else {
0143       return __sentinel<true>{ranges::end(__base_)};
0144     }
0145   }
0146
0147   _LIBCPP_HIDE_FROM_ABI constexpr auto size()
0148     requires sized_range<_View>
0149   {
0150     auto __n = ranges::size(__base_);
0151     return ranges::min(__n, static_cast<decltype(__n)>(__count_));
0152   }
0153
0154   _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
0155     requires sized_range<const _View>
0156   {
0157     auto __n = ranges::size(__base_);
0158     return ranges::min(__n, static_cast<decltype(__n)>(__count_));
0159   }
0160 };
0161
0162 template <view _View>
0163 template <bool _Const>
0164 class take_view<_View>::__sentinel {
0165   using _Base = __maybe_const<_Const, _View>;
0166   template <bool _OtherConst>
0167   using _Iter                                        = counted_iterator<iterator_t<__maybe_const<_OtherConst, _View>>>;
0168   _LIBCPP_NO_UNIQUE_ADDRESS sentinel_t<_Base> __end_ = sentinel_t<_Base>();
0169
0170   template <bool>
0171   friend class take_view<_View>::__sentinel;
0172
0173 public:
0174   _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
0175
0176   _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(std::move(__end)) {}
0177
0178   _LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __s)
0179     requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
0180       : __end_(std::move(__s.__end_)) {}
0181
0182   _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Base> base() const { return __end_; }
0183
0184   _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const _Iter<_Const>& __lhs, const __sentinel& __rhs) {
0185     return __lhs.count() == 0 || __lhs.base() == __rhs.__end_;
0186   }
0187
0188   template <bool _OtherConst = !_Const>
0189     requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
0190   _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const _Iter<_OtherConst>& __lhs, const __sentinel& __rhs) {
0191     return __lhs.count() == 0 || __lhs.base() == __rhs.__end_;
0192   }
0193 };
0194
0195 template <class _Range>
0196 take_view(_Range&&, range_difference_t<_Range>) -> take_view<views::all_t<_Range>>;
0197
0198 template <class _Tp>
0199 inline constexpr bool enable_borrowed_range<take_view<_Tp>> = enable_borrowed_range<_Tp>;
0200
0201 namespace views {
0202 namespace __take {
0203
0204 template <class _Tp>
0205 inline constexpr bool __is_empty_view = false;
0206
0207 template <class _Tp>
0208 inline constexpr bool __is_empty_view<empty_view<_Tp>> = true;
0209
0210 template <class _Tp>
0211 inline constexpr bool __is_passthrough_specialization = false;
0212
0213 template <class _Tp, size_t _Extent>
0214 inline constexpr bool __is_passthrough_specialization<span<_Tp, _Extent>> = true;
0215
0216 template <class _CharT, class _Traits>
0217 inline constexpr bool __is_passthrough_specialization<basic_string_view<_CharT, _Traits>> = true;
0218
0219 template <class _Iter, class _Sent, subrange_kind _Kind>
0220 inline constexpr bool __is_passthrough_specialization<subrange<_Iter, _Sent, _Kind>> = true;
0221
0222 template <class _Tp>
0223 inline constexpr bool __is_iota_specialization = false;
0224
0225 template <class _Np, class _Bound>
0226 inline constexpr bool __is_iota_specialization<iota_view<_Np, _Bound>> = true;
0227
0228 template <class _Tp>
0229 struct __passthrough_type;
0230
0231 template <class _Tp, size_t _Extent>
0232 struct __passthrough_type<span<_Tp, _Extent>> {
0233   using type = span<_Tp>;
0234 };
0235
0236 template <class _CharT, class _Traits>
0237 struct __passthrough_type<basic_string_view<_CharT, _Traits>> {
0238   using type = basic_string_view<_CharT, _Traits>;
0239 };
0240
0241 template <class _Iter, class _Sent, subrange_kind _Kind>
0242   requires requires { typename subrange<_Iter>; }
0243 struct __passthrough_type<subrange<_Iter, _Sent, _Kind>> {
0244   using type = subrange<_Iter>;
0245 };
0246
0247 template <class _Tp>
0248 using __passthrough_type_t = typename __passthrough_type<_Tp>::type;
0249
0250 struct __fn {
0251   // [range.take.overview]: the `empty_view` case.
0252   template <class _Range, convertible_to<range_difference_t<_Range>> _Np>
0253     requires __is_empty_view<remove_cvref_t<_Range>>
0254   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&&) const
0255       noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))))
0256           -> decltype(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))) {
0257     return _LIBCPP_AUTO_CAST(std::forward<_Range>(__range));
0258   }
0259
0260   // [range.take.overview]: the `span | basic_string_view | subrange` case.
0261   template <class _Range,
0262             convertible_to<range_difference_t<_Range>> _Np,
0263             class _RawRange = remove_cvref_t<_Range>,
0264             class _Dist     = range_difference_t<_Range>>
0265     requires(!__is_empty_view<_RawRange> && random_access_range<_RawRange> && sized_range<_RawRange> &&
0266              __is_passthrough_specialization<_RawRange>)
0267   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto
0268   operator()(_Range&& __rng, _Np&& __n) const noexcept(noexcept(__passthrough_type_t<_RawRange>(
0269       ranges::begin(__rng), ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))))
0270       -> decltype(__passthrough_type_t<_RawRange>(
0271           // Note: deliberately not forwarding `__rng` to guard against double moves.
0272           ranges::begin(__rng),
0273           ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))) {
0274     return __passthrough_type_t<_RawRange>(
0275         ranges::begin(__rng), ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)));
0276   }
0277
0278   // [range.take.overview]: the `iota_view` case.
0279   // clang-format off
0280   template <class _Range,
0281             convertible_to<range_difference_t<_Range>> _Np,
0282             class _RawRange = remove_cvref_t<_Range>,
0283             class _Dist     = range_difference_t<_Range>>
0284     requires (!__is_empty_view<_RawRange> &&
0285               random_access_range<_RawRange> &&
0286               sized_range<_RawRange> &&
0287               __is_iota_specialization<_RawRange>)
0288   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
0289   constexpr auto operator()(_Range&& __rng, _Np&& __n) const
0290     noexcept(noexcept(ranges::iota_view(
0291                               *ranges::begin(__rng),
0292                               *(ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))
0293                               )))
0294     -> decltype(      ranges::iota_view(
0295                               // Note: deliberately not forwarding `__rng` to guard against double moves.
0296                               *ranges::begin(__rng),
0297                               *(ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))
0298                               ))
0299     { return          ranges::iota_view(
0300                               *ranges::begin(__rng),
0301                               *(ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))
0302                               ); }
0303
0304 #if _LIBCPP_STD_VER >= 23
0305   // [range.take.overview]: the `repeat_view` "_RawRange models sized_range" case.
0306   template <class _Range,
0307             convertible_to<range_difference_t<_Range>> _Np,
0308             class _RawRange = remove_cvref_t<_Range>,
0309             class _Dist     = range_difference_t<_Range>>
0310     requires(__is_repeat_specialization<_RawRange> && sized_range<_RawRange>)
0311   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
0312     noexcept(noexcept(views::repeat(*__range.__value_, std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)))))
0313     -> decltype(      views::repeat(*__range.__value_, std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n))))
0314     { return          views::repeat(*__range.__value_, std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n))); }
0315
0316   // [range.take.overview]: the `repeat_view` "otherwise" case.
0317   template <class _Range,
0318             convertible_to<range_difference_t<_Range>> _Np,
0319             class _RawRange = remove_cvref_t<_Range>,
0320             class _Dist     = range_difference_t<_Range>>
0321     requires(__is_repeat_specialization<_RawRange> && !sized_range<_RawRange>)
0322   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
0323     noexcept(noexcept(views::repeat(*__range.__value_, static_cast<_Dist>(__n))))
0324     -> decltype(      views::repeat(*__range.__value_, static_cast<_Dist>(__n)))
0325     { return          views::repeat(*__range.__value_, static_cast<_Dist>(__n)); }
0326 #endif
0327   // clang-format on
0328
0329   // [range.take.overview]: the "otherwise" case.
0330   template <class _Range, convertible_to<range_difference_t<_Range>> _Np, class _RawRange = remove_cvref_t<_Range>>
0331   // Note: without specifically excluding the other cases, GCC sees this overload as ambiguous with the other
0332   // overloads.
0333     requires(!(__is_empty_view<_RawRange> ||
0334 #  if _LIBCPP_STD_VER >= 23
0335                __is_repeat_specialization<_RawRange> ||
0336 #  endif
0337                (__is_iota_specialization<_RawRange> && sized_range<_RawRange> && random_access_range<_RawRange>) ||
0338                (__is_passthrough_specialization<_RawRange> && sized_range<_RawRange> &&
0339                 random_access_range<_RawRange>)))
0340   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
0341       noexcept(noexcept(take_view(std::forward<_Range>(__range), std::forward<_Np>(__n))))
0342           -> decltype(take_view(std::forward<_Range>(__range), std::forward<_Np>(__n))) {
0343     return take_view(std::forward<_Range>(__range), std::forward<_Np>(__n));
0344   }
0345
0346   template <class _Np>
0347     requires constructible_from<decay_t<_Np>, _Np>
0348   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Np&& __n) const
0349       noexcept(is_nothrow_constructible_v<decay_t<_Np>, _Np>) {
0350     return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Np>(__n)));
0351   }
0352 };
0353
0354 } // namespace __take
0355
0356 inline namespace __cpo {
0357 inline constexpr auto take = __take::__fn{};
0358 } // namespace __cpo
0359 } // namespace views
0360
0361 } // namespace ranges
0362
0363 #endif // _LIBCPP_STD_VER >= 20
0364
0365 _LIBCPP_END_NAMESPACE_STD
0366
0367 _LIBCPP_POP_MACROS
0368
0369 #endif // _LIBCPP___CXX03___RANGES_TAKE_VIEW_H