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-no-concepts 11 // UNSUPPORTED: gcc-10 12 13 // template<class D> 14 // requires is_class_v<D> && same_as<D, remove_cv_t<D>> 15 // class view_interface; 16 17 #include <ranges> 18 19 #include <cassert> 20 #include "test_macros.h" 21 #include "test_iterators.h" 22 23 template<class T> 24 concept ValidViewInterfaceType = requires { typename std::ranges::view_interface<T>; }; 25 26 struct Empty { }; 27 28 static_assert(!ValidViewInterfaceType<void>); 29 static_assert(!ValidViewInterfaceType<void*>); 30 static_assert(!ValidViewInterfaceType<Empty*>); 31 static_assert(!ValidViewInterfaceType<Empty const>); 32 static_assert(!ValidViewInterfaceType<Empty &>); 33 static_assert( ValidViewInterfaceType<Empty>); 34 35 static_assert(std::derived_from<std::ranges::view_interface<Empty>, std::ranges::view_base>); 36 37 using InputIter = cpp20_input_iterator<const int*>; 38 39 struct InputRange : std::ranges::view_interface<InputRange> { 40 int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 41 constexpr InputIter begin() const { return InputIter(buff); } 42 constexpr InputIter end() const { return InputIter(buff + 8); } 43 }; 44 45 struct NotSizedSentinel { 46 using value_type = int; 47 using difference_type = std::ptrdiff_t; 48 using iterator_concept = std::forward_iterator_tag; 49 50 explicit NotSizedSentinel() = default; 51 explicit NotSizedSentinel(int*); 52 int& operator*() const; 53 NotSizedSentinel& operator++(); 54 NotSizedSentinel operator++(int); 55 bool operator==(NotSizedSentinel const&) const; 56 }; 57 static_assert(std::forward_iterator<NotSizedSentinel>); 58 59 using ForwardIter = forward_iterator<int*>; 60 61 // So that we conform to sized_sentinel_for. 62 constexpr std::ptrdiff_t operator-(const ForwardIter& x, const ForwardIter& y) { 63 return x.base() - y.base(); 64 } 65 66 struct ForwardRange : std::ranges::view_interface<ForwardRange> { 67 int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 68 constexpr ForwardIter begin() const { return ForwardIter(const_cast<int*>(buff)); } 69 constexpr ForwardIter end() const { return ForwardIter(const_cast<int*>(buff) + 8); } 70 }; 71 72 struct MoveOnlyForwardRange : std::ranges::view_interface<MoveOnlyForwardRange> { 73 int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 74 MoveOnlyForwardRange(MoveOnlyForwardRange const&) = delete; 75 MoveOnlyForwardRange(MoveOnlyForwardRange &&) = default; 76 MoveOnlyForwardRange() = default; 77 constexpr ForwardIter begin() const { return ForwardIter(const_cast<int*>(buff)); } 78 constexpr ForwardIter end() const { return ForwardIter(const_cast<int*>(buff) + 8); } 79 }; 80 81 struct EmptyIsTrue : std::ranges::view_interface<EmptyIsTrue> { 82 int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 83 constexpr ForwardIter begin() const { return ForwardIter(const_cast<int*>(buff)); } 84 constexpr ForwardIter end() const { return ForwardIter(const_cast<int*>(buff) + 8); } 85 constexpr bool empty() const { return true; } 86 }; 87 88 struct SizeIsTen : std::ranges::view_interface<SizeIsTen> { 89 int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 90 constexpr ForwardIter begin() const { return ForwardIter(const_cast<int*>(buff)); } 91 constexpr ForwardIter end() const { return ForwardIter(const_cast<int*>(buff) + 8); } 92 constexpr size_t size() const { return 10; } 93 }; 94 95 using RAIter = random_access_iterator<int*>; 96 97 struct RARange : std::ranges::view_interface<RARange> { 98 int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 99 constexpr RAIter begin() const { return RAIter(const_cast<int*>(buff)); } 100 constexpr RAIter end() const { return RAIter(const_cast<int*>(buff) + 8); } 101 }; 102 103 using ContIter = contiguous_iterator<const int*>; 104 105 struct ContRange : std::ranges::view_interface<ContRange> { 106 int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 107 constexpr ContIter begin() const { return ContIter(buff); } 108 constexpr ContIter end() const { return ContIter(buff + 8); } 109 }; 110 111 struct DataIsNull : std::ranges::view_interface<DataIsNull> { 112 int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 113 constexpr ContIter begin() const { return ContIter(buff); } 114 constexpr ContIter end() const { return ContIter(buff + 8); } 115 constexpr const int *data() const { return nullptr; } 116 }; 117 118 template<bool IsNoexcept> 119 struct BoolConvertibleComparison : std::ranges::view_interface<BoolConvertibleComparison<IsNoexcept>> { 120 struct ResultType { 121 bool value; 122 constexpr operator bool() const noexcept(IsNoexcept) { return value; } 123 }; 124 125 struct SentinelType { 126 int *base_; 127 SentinelType() = default; 128 explicit constexpr SentinelType(int *base) : base_(base) {} 129 friend constexpr ResultType operator==(ForwardIter const& iter, SentinelType const& sent) noexcept { return {iter.base() == sent.base_}; } 130 friend constexpr ResultType operator==(SentinelType const& sent, ForwardIter const& iter) noexcept { return {iter.base() == sent.base_}; } 131 friend constexpr ResultType operator!=(ForwardIter const& iter, SentinelType const& sent) noexcept { return {iter.base() != sent.base_}; } 132 friend constexpr ResultType operator!=(SentinelType const& sent, ForwardIter const& iter) noexcept { return {iter.base() != sent.base_}; } 133 }; 134 135 int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 136 constexpr ForwardIter begin() const noexcept { return ForwardIter(const_cast<int*>(buff)); } 137 constexpr SentinelType end() const noexcept { return SentinelType(const_cast<int*>(buff) + 8); } 138 }; 139 140 template<class T> 141 concept EmptyInvocable = requires (T const& obj) { obj.empty(); }; 142 143 template<class T> 144 concept BoolOpInvocable = requires (T const& obj) { bool(obj); }; 145 146 constexpr bool testEmpty() { 147 static_assert(!EmptyInvocable<InputRange>); 148 static_assert( EmptyInvocable<ForwardRange>); 149 150 static_assert(!BoolOpInvocable<InputRange>); 151 static_assert( BoolOpInvocable<ForwardRange>); 152 153 ForwardRange forwardRange; 154 assert(!forwardRange.empty()); 155 assert(!static_cast<ForwardRange const&>(forwardRange).empty()); 156 157 assert(forwardRange); 158 assert(static_cast<ForwardRange const&>(forwardRange)); 159 160 assert(!std::ranges::empty(forwardRange)); 161 assert(!std::ranges::empty(static_cast<ForwardRange const&>(forwardRange))); 162 163 EmptyIsTrue emptyTrue; 164 assert(emptyTrue.empty()); 165 assert(static_cast<EmptyIsTrue const&>(emptyTrue).empty()); 166 assert(!emptyTrue.std::ranges::view_interface<EmptyIsTrue>::empty()); 167 168 assert(!emptyTrue); 169 assert(!static_cast<EmptyIsTrue const&>(emptyTrue)); 170 assert(!emptyTrue.std::ranges::view_interface<EmptyIsTrue>::operator bool()); 171 172 assert(std::ranges::empty(emptyTrue)); 173 assert(std::ranges::empty(static_cast<EmptyIsTrue const&>(emptyTrue))); 174 175 // Try calling empty on an rvalue. 176 MoveOnlyForwardRange moveOnly; 177 assert(!std::move(moveOnly).empty()); 178 179 BoolConvertibleComparison<true> boolConv; 180 BoolConvertibleComparison<false> boolConv2; 181 static_assert(noexcept(boolConv.empty())); 182 static_assert(!noexcept(boolConv2.empty())); 183 184 assert(!boolConv.empty()); 185 assert(!static_cast<BoolConvertibleComparison<true> const&>(boolConv).empty()); 186 187 assert(boolConv); 188 assert(static_cast<BoolConvertibleComparison<true> const&>(boolConv)); 189 190 assert(!std::ranges::empty(boolConv)); 191 assert(!std::ranges::empty(static_cast<BoolConvertibleComparison<true> const&>(boolConv))); 192 193 return true; 194 } 195 196 template<class T> 197 concept DataInvocable = requires (T const& obj) { obj.data(); }; 198 199 constexpr bool testData() { 200 static_assert(!DataInvocable<ForwardRange>); 201 static_assert( DataInvocable<ContRange>); 202 203 ContRange contiguous; 204 assert(contiguous.data() == contiguous.buff); 205 assert(static_cast<ContRange const&>(contiguous).data() == contiguous.buff); 206 207 assert(std::ranges::data(contiguous) == contiguous.buff); 208 assert(std::ranges::data(static_cast<ContRange const&>(contiguous)) == contiguous.buff); 209 210 DataIsNull dataNull; 211 assert(dataNull.data() == nullptr); 212 assert(static_cast<DataIsNull const&>(dataNull).data() == nullptr); 213 assert(dataNull.std::ranges::view_interface<DataIsNull>::data() == dataNull.buff); 214 215 assert(std::ranges::data(dataNull) == nullptr); 216 assert(std::ranges::data(static_cast<DataIsNull const&>(dataNull)) == nullptr); 217 218 return true; 219 } 220 221 template<class T> 222 concept SizeInvocable = requires (T const& obj) { obj.size(); }; 223 224 constexpr bool testSize() { 225 static_assert(!SizeInvocable<InputRange>); 226 static_assert(!SizeInvocable<NotSizedSentinel>); 227 static_assert( SizeInvocable<ForwardRange>); 228 229 ForwardRange forwardRange; 230 assert(forwardRange.size() == 8); 231 assert(static_cast<ForwardRange const&>(forwardRange).size() == 8); 232 233 assert(std::ranges::size(forwardRange) == 8); 234 assert(std::ranges::size(static_cast<ForwardRange const&>(forwardRange)) == 8); 235 236 SizeIsTen sizeTen; 237 assert(sizeTen.size() == 10); 238 assert(static_cast<SizeIsTen const&>(sizeTen).size() == 10); 239 assert(sizeTen.std::ranges::view_interface<SizeIsTen>::size() == 8); 240 241 assert(std::ranges::size(sizeTen) == 10); 242 assert(std::ranges::size(static_cast<SizeIsTen const&>(sizeTen)) == 10); 243 244 return true; 245 } 246 247 template<class T> 248 concept SubscriptInvocable = requires (T const& obj, size_t n) { obj[n]; }; 249 250 constexpr bool testSubscript() { 251 static_assert(!SubscriptInvocable<ForwardRange>); 252 static_assert( SubscriptInvocable<RARange>); 253 254 RARange randomAccess; 255 assert(randomAccess[2] == 2); 256 assert(static_cast<RARange const&>(randomAccess)[2] == 2); 257 randomAccess[2] = 3; 258 assert(randomAccess[2] == 3); 259 260 return true; 261 } 262 263 template<class T> 264 concept FrontInvocable = requires (T const& obj) { obj.front(); }; 265 266 template<class T> 267 concept BackInvocable = requires (T const& obj) { obj.back(); }; 268 269 constexpr bool testFrontBack() { 270 static_assert(!FrontInvocable<InputRange>); 271 static_assert( FrontInvocable<ForwardRange>); 272 static_assert(!BackInvocable<ForwardRange>); 273 static_assert( BackInvocable<RARange>); 274 275 ForwardRange forwardRange; 276 assert(forwardRange.front() == 0); 277 assert(static_cast<ForwardRange const&>(forwardRange).front() == 0); 278 forwardRange.front() = 2; 279 assert(forwardRange.front() == 2); 280 281 RARange randomAccess; 282 assert(randomAccess.front() == 0); 283 assert(static_cast<RARange const&>(randomAccess).front() == 0); 284 randomAccess.front() = 2; 285 assert(randomAccess.front() == 2); 286 287 assert(randomAccess.back() == 7); 288 assert(static_cast<RARange const&>(randomAccess).back() == 7); 289 randomAccess.back() = 2; 290 assert(randomAccess.back() == 2); 291 292 return true; 293 } 294 295 int main(int, char**) { 296 testEmpty(); 297 static_assert(testEmpty()); 298 299 testData(); 300 static_assert(testData()); 301 302 testSize(); 303 static_assert(testSize()); 304 305 testSubscript(); 306 static_assert(testSubscript()); 307 308 testFrontBack(); 309 static_assert(testFrontBack()); 310 311 return 0; 312 } 313