From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id D58733858CDB for ; Tue, 11 Apr 2023 14:58:47 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org D58733858CDB Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1681225127; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=u49arJwRPZFEzrV3tWPy/pVMt7jNRjaKIGEkeJs3IRs=; b=CF4xGflZeNYhJ/U+Wha5Kl9PL8WkfXDESsYaYLAtpSLFGd2P2KsH66sUODmshaxUVIzuKf KAapRAr7RsqRHuBSSeOp90diszWN31o6STZjyZI9sn51qKt2nbZ6sYmtYFtLxNt6NheYrN e92F1yo8XWBSX6d6KVVjVWMhmdqrego= Received: from mail-qv1-f69.google.com (mail-qv1-f69.google.com [209.85.219.69]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-426-3D3WO7PrN8ad9FV1bZLu6g-1; Tue, 11 Apr 2023 10:58:46 -0400 X-MC-Unique: 3D3WO7PrN8ad9FV1bZLu6g-1 Received: by mail-qv1-f69.google.com with SMTP id c16-20020a0cd610000000b005a9cf5f609eso4322049qvj.15 for ; Tue, 11 Apr 2023 07:58:46 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1681225125; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=u49arJwRPZFEzrV3tWPy/pVMt7jNRjaKIGEkeJs3IRs=; b=7bB8/TFMlu94JOoh4D8YooI8W0pE/qaQRl3AuM4lxC8xPhI2AuJH93O+yCSMhQN+iU 0xfXotB+meSZDwYdca3IRbSs82rzU5M+lXUBc7sNjqUpVDuhsqhhLhXk+xdTDLq1RXxw +IJU/6tAFctT2lQpaULS7JXlspxT/kkOYrCabwDGlYAIY26CI7/PFV3+jbkDSuKg/h62 SuElOoEMYRFQcWf6cjOY7YpdCMLZUxKkZEApREI7mzv/v8uKAYxkhPO3qWqxKdo87dAc Sodsj1/alesm826ebJF+m2K8ho7zx/TpQmdk2d+2SYmupxvTDokLVc5+SBjZr/pjuFxd dNSA== X-Gm-Message-State: AAQBX9c6hVFurgq8Pq4hB4UD3nTKWkjlQpWJN9d5364yUc6dxdd/CE85 QVDrn3GvBYJZuFFGHF8dxxNofQ3+EF0htQRC0ADrMUoVUZ+Xt/qGbx6dKo9I65y4n/zaiVY7a2g ocDjuw9U6V1Kt/qD5XyJkVmManwHz403wKNHFPWeLkRNX98MOU3Y4ie0aY7qa5haZvZFY8T8WF2 g= X-Received: by 2002:a05:622a:1a23:b0:3dc:1e1f:fe0e with SMTP id f35-20020a05622a1a2300b003dc1e1ffe0emr26076379qtb.35.1681225125322; Tue, 11 Apr 2023 07:58:45 -0700 (PDT) X-Google-Smtp-Source: AKy350a9UC9f3FeCEVgdCJtPaJDShn7ZdKa9MKzFOvdAzfiI7mch2AQdKvQYFhgz46HFBkhwaRxIAA== X-Received: by 2002:a05:622a:1a23:b0:3dc:1e1f:fe0e with SMTP id f35-20020a05622a1a2300b003dc1e1ffe0emr26076332qtb.35.1681225124889; Tue, 11 Apr 2023 07:58:44 -0700 (PDT) Received: from localhost.localdomain (ool-457670bb.dyn.optonline.net. [69.118.112.187]) by smtp.gmail.com with ESMTPSA id q19-20020a05620a2a5300b0074a88d396e8sm2860775qkp.38.2023.04.11.07.58.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 11 Apr 2023 07:58:44 -0700 (PDT) From: Patrick Palka To: gcc-patches@gcc.gnu.org Cc: libstdc++@gcc.gnu.org, Patrick Palka Subject: [PATCH] libstdc++: Implement ranges::enumerate_view from P2164R9 Date: Tue, 11 Apr 2023 10:58:38 -0400 Message-Id: <20230411145838.2862361-1-ppalka@redhat.com> X-Mailer: git-send-email 2.40.0.315.g0607f793cb MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset="US-ASCII"; x-default=true X-Spam-Status: No, score=-13.5 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,KAM_NUMSUBJECT,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,SPF_HELO_NONE,SPF_NONE,TXREP autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: Tested on x86_64-pc-linux-gnu, does this look OK for trunk perhaps? libstdc++-v3/ChangeLog: * include/std/ranges (__cpp_lib_ranges_enumerate): Define for C++23. (__detail::__range_with_movable_reference): Likewise. (enumerate_view): Likewise. (enumerate_view::_Iterator): Likewise. (enumerate_view::_Sentinel): Likewise. * include/std/version (__cpp_lib_ranges_enumerate): Likewise. * testsuite/std/ranges/version_c++23.cc: Verify value of __cpp_lib_ranges_enumerate. * testsuite/std/ranges/adaptors/enumerate/1.cc: New test. --- libstdc++-v3/include/std/ranges | 303 ++++++++++++++++++ libstdc++-v3/include/std/version | 1 + .../std/ranges/adaptors/enumerate/1.cc | 102 ++++++ .../testsuite/std/ranges/version_c++23.cc | 4 + 4 files changed, 410 insertions(+) create mode 100644 libstdc++-v3/testsuite/std/ranges/adaptors/enumerate/1.cc diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges index 14754c125ff..be71c370eb7 100644 --- a/libstdc++-v3/include/std/ranges +++ b/libstdc++-v3/include/std/ranges @@ -8732,6 +8732,309 @@ namespace views::__adaptor inline constexpr _AsConst as_const; } + +#define __cpp_lib_ranges_enumerate 202302L + + namespace __detail + { + template + concept __range_with_movable_reference = input_range<_Range> + && move_constructible> + && move_constructible>; + } + + template + requires __detail::__range_with_movable_reference<_Vp> + class enumerate_view : public view_interface> + { + _Vp _M_base = _Vp(); + + template class _Iterator; + template class _Sentinel; + + public: + enumerate_view() requires default_initializable<_Vp> = default; + + constexpr explicit + enumerate_view(_Vp __base) + : _M_base(std::move(__base)) + { } + + constexpr auto + begin() requires (!__detail::__simple_view<_Vp>) + { return _Iterator(ranges::begin(_M_base), 0); } + + constexpr auto + begin() const requires __detail::__range_with_movable_reference + { return _Iterator(ranges::begin(_M_base), 0); } + + constexpr auto + end() requires (!__detail::__simple_view<_Vp>) + { + if constexpr (common_range<_Vp> && sized_range<_Vp>) + return _Iterator(ranges::end(_M_base), ranges::distance(_M_base)); + else + return _Sentinel(ranges::end(_M_base)); + } + + constexpr auto + end() const requires __detail::__range_with_movable_reference + { + if constexpr (common_range && sized_range) + return _Iterator(ranges::end(_M_base), ranges::distance(_M_base)); + else + return _Sentinel(ranges::end(_M_base)); + } + + constexpr auto + size() requires sized_range<_Vp> + { return ranges::size(_M_base); } + + constexpr auto + size() const requires sized_range + { return ranges::size(_M_base); } + + constexpr _Vp + base() const & requires copy_constructible<_Vp> + { return _M_base; } + + constexpr _Vp + base() && + { return std::move(_M_base); } + }; + + template + enumerate_view(_Range&&) -> enumerate_view>; + + template + inline constexpr bool enable_borrowed_range> + = enable_borrowed_range<_Tp>; + + template + requires __detail::__range_with_movable_reference<_Vp> + template + class enumerate_view<_Vp>::_Iterator + { + using _Base = __maybe_const_t<_Const, _Vp>; + + static auto + _S_iter_concept() + { + if constexpr (random_access_range<_Base>) + return random_access_iterator_tag{}; + else if constexpr (bidirectional_range<_Base>) + return bidirectional_iterator_tag{}; + else if constexpr (forward_range<_Base>) + return forward_iterator_tag{}; + else + return input_iterator_tag{}; + } + + friend enumerate_view; + + public: + using iterator_category = input_iterator_tag; + using iterator_concept = decltype(_S_iter_concept()); + using difference_type = range_difference_t<_Base>; + using value_type = tuple>; + + private: + using __reference_type = tuple>; + + iterator_t<_Base> _M_current = iterator_t<_Base>(); + difference_type _M_pos = 0; + + constexpr explicit + _Iterator(iterator_t<_Base> __current, difference_type __pos) + : _M_current(std::move(__current)), _M_pos(__pos) + { } + + public: + _Iterator() requires default_initializable> = default; + + constexpr + _Iterator(_Iterator __i) + requires _Const && convertible_to, iterator_t<_Base>> + : _M_current(std::move(__i._M_current)), _M_pos(__i._M_pos) + { } + + constexpr const iterator_t<_Base> & + base() const & noexcept + { return _M_current; } + + constexpr iterator_t<_Base> + base() && + { return std::move(_M_current); } + + constexpr difference_type + index() const noexcept + { return _M_pos; } + + constexpr auto + operator*() const + { return __reference_type(_M_pos, *_M_current); } + + constexpr _Iterator& + operator++() + { + ++_M_current; + ++_M_pos; + return *this; + } + + constexpr void + operator++(int) + { ++*this; } + + constexpr _Iterator + operator++(int) requires forward_range<_Base> + { + auto __tmp = *this; + ++*this; + return __tmp; + } + + constexpr _Iterator& + operator--() requires bidirectional_range<_Base> + { + --_M_current; + --_M_pos; + return *this; + } + + constexpr _Iterator + operator--(int) requires bidirectional_range<_Base> + { + auto __tmp = *this; + --*this; + return __tmp; + } + + constexpr _Iterator& + operator+=(difference_type __n) requires random_access_range<_Base> + { + _M_current += __n; + _M_pos += __n; + return *this; + } + + constexpr _Iterator& + operator-=(difference_type __n) requires random_access_range<_Base> + { + _M_current -= __n; + _M_pos -= __n; + return *this; + } + + constexpr auto + operator[](difference_type __n) const requires random_access_range<_Base> + { return __reference_type(_M_pos + __n, _M_current[__n]); } + + friend constexpr bool + operator==(const _Iterator& __x, const _Iterator& __y) noexcept + { return __x._M_pos == __y._M_pos; } + + friend constexpr strong_ordering + operator<=>(const _Iterator& __x, const _Iterator& __y) noexcept + { return __x._M_pos <=> __y._M_pos; } + + friend constexpr _Iterator + operator+(const _Iterator& __x, difference_type __y) + requires random_access_range<_Base> + { return (auto(__x) += __y); } + + friend constexpr _Iterator + operator+(difference_type __x, const _Iterator& __y) + requires random_access_range<_Base> + { return auto(__y) += __x; } + + friend constexpr _Iterator + operator-(const _Iterator& __x, difference_type __y) + requires random_access_range<_Base> + { return auto(__x) -= __y; } + + friend constexpr difference_type + operator-(const _Iterator& __x, const _Iterator& __y) + { return __x._M_pos - __y._M_pos; } + + friend constexpr auto + iter_move(const _Iterator& __i) + noexcept(noexcept(ranges::iter_move(__i._M_current)) + && is_nothrow_move_constructible_v>) + { + return tuple> + (__i._M_pos, ranges::iter_move(__i._M_current)); + } + }; + + template + requires __detail::__range_with_movable_reference<_Vp> + template + class enumerate_view<_Vp>::_Sentinel + { + using _Base = __maybe_const_t<_Const, _Vp>; + + sentinel_t<_Base> _M_end = sentinel_t<_Base>(); + + constexpr explicit + _Sentinel(sentinel_t<_Base> __end) + : _M_end(std::move(__end)) + { } + + friend enumerate_view; + + public: + _Sentinel() = default; + + constexpr + _Sentinel(_Sentinel __other) + requires _Const && convertible_to, sentinel_t<_Base>> + : _M_end(std::move(__other._M_end)) + { } + + constexpr sentinel_t<_Base> + base() const + { return _M_end; } + + template + requires sentinel_for, iterator_t<__maybe_const_t<_OtherConst, _Vp>>> + friend constexpr bool + operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y) + { return __x._M_current == __y._M_end; } + + template + requires sized_sentinel_for, iterator_t<__maybe_const_t<_OtherConst, _Vp>>> + friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>> + operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y) + { return __x._M_current - __y._M_end; } + + template + requires sized_sentinel_for, iterator_t<__maybe_const_t<_OtherConst, _Vp>>> + friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>> + operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y) + { return __x._M_end - __y._M_current; } + }; + + namespace views + { + namespace __detail + { + template + concept __can_enumerate_view + = requires { enumerate_view>(std::declval<_Tp>()); }; + } + + struct _Enumerate : __adaptor::_RangeAdaptorClosure + { + template + requires __detail::__can_enumerate_view<_Range> + constexpr auto + operator() [[nodiscard]] (_Range&& __r) const + { return enumerate_view>(std::forward<_Range>(__r)); } + }; + + inline constexpr _Enumerate enumerate; + } #endif // C++23 } // namespace ranges diff --git a/libstdc++-v3/include/std/version b/libstdc++-v3/include/std/version index dfe1e242a2a..42f7e9e15b7 100644 --- a/libstdc++-v3/include/std/version +++ b/libstdc++-v3/include/std/version @@ -340,6 +340,7 @@ #define __cpp_lib_ranges_cartesian_product 202207L #define __cpp_lib_ranges_as_rvalue 202207L #define __cpp_lib_ranges_as_const 202207L +#define __cpp_lib_ranges_enumerate 202302L #if __cpp_constexpr_dynamic_alloc # if _GLIBCXX_HOSTED # define __cpp_lib_constexpr_bitset 202202L diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/enumerate/1.cc b/libstdc++-v3/testsuite/std/ranges/adaptors/enumerate/1.cc new file mode 100644 index 00000000000..445d9854c8c --- /dev/null +++ b/libstdc++-v3/testsuite/std/ranges/adaptors/enumerate/1.cc @@ -0,0 +1,102 @@ +// { dg-options "-std=gnu++23" } +// { dg-do run { target c++23 } } + +#include +#include +#include +#include +#include + +#if __cpp_lib_ranges_enumerate != 202302L +# error "Feature-test macro __cpp_lib_ranges_enumerate has wrong value in " +#endif + +namespace ranges = std::ranges; +namespace views = std::views; + +using __gnu_test::test_input_range; +using __gnu_test::test_forward_range; +using __gnu_test::test_bidirectional_range; +using __gnu_test::test_random_access_range; + +constexpr bool +test01() +{ + int x[] = {1, 2, 3}; + auto v = x | views::enumerate; + + VERIFY( ranges::equal(v | views::keys, (int[]){0, 1, 2}) ); + VERIFY( ranges::equal(v | views::values, (int[]){1, 2, 3}) ); + + auto it = v.begin(); + VERIFY( it == it ); + VERIFY( it != it + 1 ); + VERIFY( it != v.end() ); + + VERIFY( it.index() == 0 ); + VERIFY( (++it).index() == 1 ); + VERIFY( (++it).index() == 2 ); + + return true; +} + +template class Container> +void +test02() +{ + int x[] = {1, 2, 3}; + Container rx (x); + auto v = rx | views::enumerate; + + int j = 0; + for (auto [i, y] : v) + { + VERIFY (&y == &x[j]); + VERIFY (j == i); + ++j; + } + VERIFY (j == ranges::size(x)); + + if constexpr (ranges::bidirectional_range) + { + static_assert(ranges::bidirectional_range); + for (auto [i, y] : v | views::reverse) + { + --j; + VERIFY (&y == &x[j]); + VERIFY (j == i); + } + VERIFY (j == 0); + } + + if constexpr (ranges::random_access_range) + { + static_assert(ranges::random_access_range); + for (j = 0; j < ranges::ssize(x); ++j) + { + VERIFY (std::get<0>(v[j]) == j); + VERIFY (&std::get<1>(v[j]) == &x[j]); + VERIFY (*(v.begin() + j) == v[j]); + VERIFY (*(v.begin() + (ranges::size(x) - 1) - j) == v[ranges::size(x) - 1 - j]); + VERIFY (v.begin() + j + 1 > v.begin() + j ); + VERIFY (v.begin() + j < v.begin() + j + 1 ); + VERIFY (v.begin() + j >= v.begin() ); + VERIFY (v.begin() <= v.begin() + j ); + VERIFY( v.begin() + j != v.end() ); + VERIFY( v.begin() + j - v.begin() == j ); + VERIFY( v.end() - (v.begin() + j) == ranges::ssize(x) - j ); + } + VERIFY( v.begin() + j == v.end() ); + } +} + +int +main() +{ + static_assert(test01()); + + test02(); + test02(); + test02(); + test02(); +} diff --git a/libstdc++-v3/testsuite/std/ranges/version_c++23.cc b/libstdc++-v3/testsuite/std/ranges/version_c++23.cc index fc98bef922a..e2c14edc8ef 100644 --- a/libstdc++-v3/testsuite/std/ranges/version_c++23.cc +++ b/libstdc++-v3/testsuite/std/ranges/version_c++23.cc @@ -48,3 +48,7 @@ #if __cpp_lib_ranges_as_const != 202207L # error "Feature-test macro __cpp_lib_ranges_as_const has wrong value in " #endif + +#if __cpp_lib_ranges_enumerate != 202302L +# error "Feature-test macro __cpp_lib_ranges_enumerate has wrong value in " +#endif -- 2.40.0.315.g0607f793cb