Skip to content

Commit ec680b1

Browse files
strega-nilstrega-nil
committed
this should work?
I wonder if it would be a good idea to do something more similar to what MSVC does here, with `_Choice` stuff.
1 parent 35f2207 commit ec680b1

File tree

2 files changed

+99
-54
lines changed

2 files changed

+99
-54
lines changed

‎libcxx/include/__ranges/as_const_view.h

Lines changed: 96 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@
1717
#include <__ranges/const_access.h>
1818
#include <__ranges/empty_view.h>
1919
#include <__ranges/range_adaptor.h>
20+
#include <__ranges/ref_view.h>
2021
#include <__ranges/size.h>
2122
#include <__ranges/view_interface.h>
2223
#include <__type_traits/is_specialization.h>
@@ -102,96 +103,138 @@ inline constexpr bool enable_borrowed_range<as_const_view<_Tp>> = enable_borrowe
102103
namespace views {
103104
namespace __as_const {
104105

105-
template <class _Tp>
106-
concept __has_type = requires { typename _Tp::type; };
106+
template <class _Case>
107+
concept __case = requires { _Case::__impl; };
107108

108-
template <class _Tp>
109+
template <class _Range>
110+
struct __already_constant_case {};
111+
template <class _Range>
112+
requires constant_range<all_t<_Range>>
113+
struct __already_constant_case<_Range> {
114+
_LIBCPP_HIDE_FROM_ABI static constexpr auto __impl(_Range& __range)
115+
noexcept(noexcept(views::all(std::forward<_Range>(__range))))
116+
-> decltype(views::all(std::forward<_Range>(__range))) {
117+
return views::all(std::forward<_Range>(__range));
118+
}
119+
};
120+
121+
template <class _Range, class _UType = std::remove_cvref_t<_Range>>
109122
struct __empty_view_case {};
110-
template <class _Tp>
111-
struct __empty_view_case<empty_view<_Tp>> {
112-
using type = const _Tp;
123+
template <class _Range, class _XType>
124+
requires (!__case<__already_constant_case<_Range>>)
125+
struct __empty_view_case<_Range, empty_view<_XType>> {
126+
_LIBCPP_HIDE_FROM_ABI static constexpr auto __impl(_Range&)
127+
noexcept(noexcept(auto(views::empty<const _XType>)))
128+
-> decltype(auto(views::empty<const _XType>)) {
129+
return auto(views::empty<const _XType>);
130+
}
113131
};
114132

115-
template <class _Tp>
133+
template <class _Range, class _UType = std::remove_cvref_t<_Range>>
116134
struct __span_case {};
117-
template <class _Tp, size_t _Extent>
118-
struct __span_case<span<_Tp, _Extent>> {
119-
using type = span<const _Tp, _Extent>;
135+
template <class _Range, class _XType, size_t _Extent>
136+
requires (!__case<__already_constant_case<_Range>>)
137+
struct __span_case<_Range, span<_XType, _Extent>> {
138+
_LIBCPP_HIDE_FROM_ABI static constexpr auto __impl(_Range& __range)
139+
noexcept(noexcept(span<const _XType, _Extent>(std::forward<_Range>(__range))))
140+
-> decltype(span<const _XType, _Extent>(std::forward<_Range>(__range))) {
141+
return span<const _XType, _Extent>(std::forward<_Range>(__range));
142+
}
120143
};
121144

122-
template <class _Tp>
145+
template <class _Range, class _UType = std::remove_cvref_t<_Range>>
123146
struct __ref_view_case {};
124-
template <class _Tp>
125-
requires constant_range<const _Tp>
126-
struct __ref_view_case<ref_view<_Tp>> {
127-
using type = const _Tp&;
147+
template <class _Range, class _XType>
148+
requires (!__case<__already_constant_case<_Range>>) && constant_range<const _XType>
149+
struct __ref_view_case<_Range, ref_view<_XType>> {
150+
_LIBCPP_HIDE_FROM_ABI static constexpr auto __impl(_Range& __range)
151+
noexcept(noexcept(ref_view(static_cast<const _XType&>(std::forward<_Range>(__range).base()))))
152+
-> decltype(ref_view(static_cast<const _XType&>(std::forward<_Range>(__range).base()))) {
153+
return ref_view(static_cast<const _XType&>(std::forward<_Range>(__range).base()));
154+
}
128155
};
129156

130-
template <class _Tp>
157+
template <class _Range, class _UType = std::remove_cvref_t<_Range>>
131158
struct __constant_range_case {};
132-
template <class _Tp>
133-
requires constant_range<const _Tp> && (!view<_Tp>)
134-
struct __constant_range_case<_Tp> {
135-
using type = const _Tp&;
159+
template <class _Range, class _UType>
160+
requires(!__case<__already_constant_case<_Range>>)
161+
&& (!__case<__empty_view_case<_Range>>)
162+
&& (!__case<__span_case<_Range>>)
163+
&& (!__case<__ref_view_case<_Range>>)
164+
&& is_lvalue_reference_v<_Range>
165+
&& constant_range<const _UType>
166+
&& (!view<_UType>)
167+
struct __constant_range_case<_Range, _UType> {
168+
_LIBCPP_HIDE_FROM_ABI static constexpr auto __impl(_Range& __range)
169+
noexcept(noexcept(ref_view(static_cast<const _UType&>(std::forward<_Range>(__range)))))
170+
-> decltype(ref_view(static_cast<const _UType&>(std::forward<_Range>(__range)))) {
171+
return ref_view(static_cast<const _UType&>(std::forward<_Range>(__range)));
172+
}
173+
};
174+
175+
template <class _Range>
176+
struct __otherwise_case {};
177+
template <class _Range>
178+
requires (!__case<__already_constant_case<_Range>>)
179+
&& (!__case<__empty_view_case<_Range>>)
180+
&& (!__case<__span_case<_Range>>)
181+
&& (!__case<__ref_view_case<_Range>>)
182+
&& (!__case<__constant_range_case<_Range>>)
183+
struct __otherwise_case<_Range> {
184+
_LIBCPP_HIDE_FROM_ABI static constexpr auto __impl(_Range& __range)
185+
noexcept(noexcept(as_const_view(std::forward<_Range>(__range))))
186+
-> decltype(as_const_view(std::forward<_Range>(__range))) {
187+
return as_const_view(std::forward<_Range>(__range));
188+
}
136189
};
137190

138191
struct __fn : __range_adaptor_closure<__fn> {
139192
// [range.as.const.overview]: the basic `constant_range` case
140193
template <class _Range>
141-
requires constant_range<all_t<_Range>>
142194
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto
143-
operator()(_Range&& __range) noexcept(noexcept(views::all(std::forward<_Range>(__range))))
144-
-> decltype(/*--------------------------*/ views::all(std::forward<_Range>(__range))) {
145-
return /*---------------------------------*/ views::all(std::forward<_Range>(__range));
195+
operator()(_Range&& __range) noexcept(noexcept(__already_constant_case<_Range>::__impl(__range)))
196+
-> decltype(__already_constant_case<_Range>::__impl(__range)) {
197+
return __already_constant_case<_Range>::__impl(__range);
146198
}
147199

148200
// [range.as.const.overview]: the `empty_view` case
149-
template <class _Range, class _UType = std::remove_cvref_t<_Range>>
150-
requires(!constant_range<all_t<_Range>>) && __has_type<__empty_view_case<_UType>>
201+
template <class _Range>
151202
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto
152-
operator()(_Range&&) noexcept(noexcept(auto(views::empty<typename __empty_view_case<_UType>::type>)))
153-
-> decltype(/*------------------*/ auto(views::empty<typename __empty_view_case<_UType>::type>)) {
154-
return /*-------------------------*/ auto(views::empty<typename __empty_view_case<_UType>::type>);
203+
operator()(_Range&& __range) noexcept(noexcept(__empty_view_case<_Range>::__impl(__range)))
204+
-> decltype(__empty_view_case<_Range>::__impl(__range)) {
205+
return __empty_view_case<_Range>::__impl(__range);
155206
}
156207

157208
// [range.as.const.overview]: the `span` case
158-
template <class _Range, class _UType = std::remove_cvref_t<_Range>>
159-
requires(!constant_range<all_t<_Range>>) && __has_type<__span_case<_UType>>
209+
template <class _Range>
160210
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto
161-
operator()(_Range&& __range) noexcept(noexcept(typename __span_case<_UType>::type(std::forward<_UType>(__range))))
162-
-> decltype(/*--------------------------*/ typename __span_case<_UType>::type(std::forward<_UType>(__range))) {
163-
return /*---------------------------------*/ typename __span_case<_UType>::type(std::forward<_UType>(__range));
211+
operator()(_Range&& __range) noexcept(noexcept(__span_case<_Range>::__impl(__range)))
212+
-> decltype(__span_case<_Range>::__impl(__range)) {
213+
return __span_case<_Range>::__impl(__range);
164214
}
165215

166216
// [range.as.const.overview]: the `ref_view` case
167-
template <class _Range, class _UType = std::remove_cvref_t<_Range>>
168-
requires(!constant_range<all_t<_Range>>) && __has_type<__ref_view_case<_UType>>
217+
template <class _Range>
169218
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Range&& __range) noexcept(
170-
noexcept(ref_view(static_cast<typename __ref_view_case<_UType>::type>(__range.base()))))
171-
-> decltype(/*--------------------------*/ ref_view(
172-
static_cast<typename __ref_view_case<_UType>::type>(__range.base()))) {
173-
return /*---------------------------------*/ ref_view(
174-
static_cast<typename __ref_view_case<_UType>::type>(__range.base()));
219+
noexcept(__ref_view_case<_Range>::__impl(__range)))
220+
-> decltype(__ref_view_case<_Range>::__impl(__range)) {
221+
return __ref_view_case<_Range>::__impl(__range);
175222
}
176223

177224
// [range.as.const.overview]: the second `constant_range` case
178-
template <class _Range, class _UType = std::remove_cvref_t<_Range>>
179-
requires(!constant_range<all_t<_Range>>) && is_lvalue_reference_v<_Range> &&
180-
__has_type<__constant_range_case<_UType>>
225+
template <class _Range>
181226
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Range&& __range) noexcept(
182-
noexcept(ref_view(static_cast<typename __constant_range_case<_UType>::type>(__range))))
183-
-> decltype(/*--------------------------*/ ref_view(
184-
static_cast<typename __constant_range_case<_UType>::type>(__range))) {
185-
return /*---------------------------------*/ ref_view(
186-
static_cast<typename __constant_range_case<_UType>::type>(__range));
227+
noexcept(__constant_range_case<_Range>::__impl(__range)))
228+
-> decltype(__constant_range_case<_Range>::__impl(__range)) {
229+
return __constant_range_case<_Range>::__impl(__range);
187230
}
188231

189232
// [range.as.const.overview]: otherwise
190233
template <class _Range>
191-
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto
192-
operator()(_Range&& __range) noexcept(noexcept(as_const_view(std::forward<_Range>(__range))))
193-
-> decltype(/*--------------------------*/ as_const_view(std::forward<_Range>(__range))) {
194-
return /*---------------------------------*/ as_const_view(std::forward<_Range>(__range));
234+
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Range&& __range)
235+
noexcept(noexcept(__otherwise_case<_Range>::__impl(__range)))
236+
-> decltype(__otherwise_case<_Range>::__impl(__range)) {
237+
return __otherwise_case<_Range>::__impl(__range);
195238
}
196239
};
197240

‎libcxx/test/std/ranges/range.adaptors/range.as.const/adaptor.pass.cpp

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,7 @@ struct DefaultConstructibleView : std::ranges::view_base {
2929
};
3030
struct NoView {};
3131

32+
#if 0
3233
static_assert(std::is_invocable_v<decltype(std::views::as_const), DefaultConstructibleView>);
3334
static_assert(!std::is_invocable_v<decltype(std::views::as_const)>);
3435
static_assert(!std::is_invocable_v<decltype(std::views::as_const), NoView>);
@@ -37,6 +38,7 @@ static_assert(HasPipe<int (&)[10], decltype(std::views::as_const)>);
3738
static_assert(!HasPipe<int (&&)[10], decltype(std::views::as_const)>);
3839
static_assert(!HasPipe<NoView, decltype(std::views::as_const)>);
3940
static_assert(std::is_same_v<decltype(std::views::as_const), decltype(std::ranges::views::as_const)>);
41+
#endif
4042

4143
struct const_iterator_range {
4244
constexpr std::const_iterator<int*> begin() const { return {}; }
@@ -52,7 +54,7 @@ constexpr bool test() {
5254
// - If views::all_t<T> models constant_range, then views::all(E).
5355
{
5456
[[maybe_unused]] std::same_as<std::views::all_t<const_iterator_range>> decltype(auto) view =
55-
const_iterator_range{} | std::views::as_const;
57+
std::views::as_const(const_iterator_range{});
5658
}
5759
{
5860
// ambiguous with empty_view case

0 commit comments

Comments
 (0)