1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 // UNSUPPORTED: c++03, c++11, c++14, c++17
10 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
11
12 // template<range R>
13 // requires is_object_v<R>
14 // class ref_view;
15
16 #include <ranges>
17
18 #include <cassert>
19 #include "test_macros.h"
20 #include "test_iterators.h"
21
22 int globalBuff[8];
23
24 template<class T>
25 concept ValidRefView = requires { typename std::ranges::ref_view<T>; };
26
27 struct Range {
28 int start = 0;
begin(Range const & range)29 friend constexpr int* begin(Range const& range) { return globalBuff + range.start; }
end(Range const &)30 friend constexpr int* end(Range const&) { return globalBuff + 8; }
begin(Range & range)31 friend constexpr int* begin(Range& range) { return globalBuff + range.start; }
end(Range &)32 friend constexpr int* end(Range&) { return globalBuff + 8; }
33 };
34
35 struct BeginOnly {
36 friend int* begin(BeginOnly const&);
37 friend int* begin(BeginOnly &);
38 };
39
40 static_assert( ValidRefView<Range>);
41 static_assert(!ValidRefView<BeginOnly>);
42 static_assert(!ValidRefView<int (&)[4]>);
43 static_assert( ValidRefView<int[4]>);
44
45 static_assert(std::derived_from<std::ranges::ref_view<Range>, std::ranges::view_interface<std::ranges::ref_view<Range>>>);
46
47 struct RangeConvertible {
48 operator Range& ();
49 };
50
51 struct RValueRangeConvertible {
52 operator Range&& ();
53 };
54
55 static_assert( std::is_constructible_v<std::ranges::ref_view<Range>, Range&>);
56 static_assert( std::is_constructible_v<std::ranges::ref_view<Range>, RangeConvertible>);
57 static_assert(!std::is_constructible_v<std::ranges::ref_view<Range>, RValueRangeConvertible>);
58
59 struct ConstConvertibleToLValueAndRValue {
60 operator Range& () const;
61 operator Range&& () const;
62 };
63 static_assert( std::is_convertible_v<RangeConvertible, std::ranges::ref_view<Range>>);
64 static_assert(!std::is_convertible_v<RValueRangeConvertible, std::ranges::ref_view<Range>>);
65 static_assert(!std::is_convertible_v<ConstConvertibleToLValueAndRValue, std::ranges::ref_view<Range>>);
66
67 struct ForwardRange {
beginForwardRange68 constexpr forward_iterator<int*> begin() const { return forward_iterator<int*>(globalBuff); }
endForwardRange69 constexpr forward_iterator<int*> end() const { return forward_iterator<int*>(globalBuff + 8); }
70 };
71
72 struct Cpp17InputRange {
73 struct sentinel {
operator ==Cpp17InputRange74 friend constexpr bool operator==(sentinel, cpp17_input_iterator<int*> iter) { return base(iter) == globalBuff + 8; }
operator -Cpp17InputRange75 friend constexpr std::ptrdiff_t operator-(sentinel, cpp17_input_iterator<int*>) { return -8; }
operator -Cpp17InputRange76 friend constexpr std::ptrdiff_t operator-(cpp17_input_iterator<int*>, sentinel) { return 8; }
77 };
78
beginCpp17InputRange79 constexpr cpp17_input_iterator<int*> begin() const {
80 return cpp17_input_iterator<int*>(globalBuff);
81 }
endCpp17InputRange82 constexpr sentinel end() const { return {}; }
83 };
84
85 struct Cpp20InputRange {
86 struct sentinel {
operator ==Cpp20InputRange87 friend constexpr bool operator==(sentinel, const cpp20_input_iterator<int*> &iter) { return base(iter) == globalBuff + 8; }
operator -Cpp20InputRange88 friend constexpr std::ptrdiff_t operator-(sentinel, const cpp20_input_iterator<int*>&) { return -8; }
89 };
90
beginCpp20InputRange91 constexpr cpp20_input_iterator<int*> begin() const {
92 return cpp20_input_iterator<int*>(globalBuff);
93 }
endCpp20InputRange94 constexpr sentinel end() const { return {}; }
95 };
96
97 template<>
98 inline constexpr bool std::ranges::enable_borrowed_range<Cpp20InputRange> = true;
99
100 template<class R>
101 concept EmptyIsInvocable = requires (std::ranges::ref_view<R> view) { view.empty(); };
102
103 template<class R>
104 concept SizeIsInvocable = requires (std::ranges::ref_view<R> view) { view.size(); };
105
106 template<class R>
107 concept DataIsInvocable = requires (std::ranges::ref_view<R> view) { view.data(); };
108
109 // Testing ctad.
110 static_assert(std::same_as<decltype(std::ranges::ref_view(std::declval<Range&>())),
111 std::ranges::ref_view<Range>>);
112
test()113 constexpr bool test() {
114 {
115 // ref_view::base
116 Range range;
117 std::ranges::ref_view<Range> view{range};
118 assert(view.begin() == globalBuff);
119 view.base() = Range{2};
120 assert(view.begin() == globalBuff + 2);
121 }
122
123 {
124 // ref_view::begin
125 Range range1;
126 std::ranges::ref_view<Range> view1 = range1;
127 assert(view1.begin() == globalBuff);
128
129 ForwardRange range2;
130 std::ranges::ref_view<ForwardRange> view2 = range2;
131 assert(base(view2.begin()) == globalBuff);
132
133 Cpp17InputRange range3;
134 std::ranges::ref_view<Cpp17InputRange> view3 = range3;
135 assert(base(view3.begin()) == globalBuff);
136
137 Cpp20InputRange range4;
138 std::ranges::ref_view<Cpp20InputRange> view4 = range4;
139 assert(base(view4.begin()) == globalBuff);
140 }
141
142 {
143 // ref_view::end
144 Range range1;
145 std::ranges::ref_view<Range> view1 = range1;
146 assert(view1.end() == globalBuff + 8);
147
148 ForwardRange range2;
149 std::ranges::ref_view<ForwardRange> view2 = range2;
150 assert(base(view2.end()) == globalBuff + 8);
151
152 Cpp17InputRange range3;
153 std::ranges::ref_view<Cpp17InputRange> view3 = range3;
154 assert(view3.end() == cpp17_input_iterator(globalBuff + 8));
155
156 Cpp20InputRange range4;
157 std::ranges::ref_view<Cpp20InputRange> view4 = range4;
158 assert(view4.end() == cpp20_input_iterator(globalBuff + 8));
159 }
160
161 {
162 // ref_view::empty
163 Range range{8};
164 std::ranges::ref_view<Range> view1 = range;
165 assert(view1.empty());
166
167 ForwardRange range2;
168 std::ranges::ref_view<ForwardRange> view2 = range2;
169 assert(!view2.empty());
170
171 static_assert(!EmptyIsInvocable<Cpp17InputRange>);
172 static_assert(!EmptyIsInvocable<Cpp20InputRange>);
173 }
174
175 {
176 // ref_view::size
177 Range range1{8};
178 std::ranges::ref_view<Range> view1 = range1;
179 assert(view1.size() == 0);
180
181 Range range2{2};
182 std::ranges::ref_view<Range> view2 = range2;
183 assert(view2.size() == 6);
184
185 static_assert(!SizeIsInvocable<ForwardRange>);
186 }
187
188 {
189 // ref_view::data
190 Range range1;
191 std::ranges::ref_view<Range> view1 = range1;
192 assert(view1.data() == globalBuff);
193
194 Range range2{2};
195 std::ranges::ref_view<Range> view2 = range2;
196 assert(view2.data() == globalBuff + 2);
197
198 static_assert(!DataIsInvocable<ForwardRange>);
199 }
200
201 return true;
202 }
203
main(int,char **)204 int main(int, char**) {
205 test();
206 static_assert(test());
207
208 return 0;
209 }
210