1 #ifndef TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TAKE_TYPES_H 2 #define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TAKE_TYPES_H 3 4 #include <ranges> 5 6 #include "test_macros.h" 7 #include "test_iterators.h" 8 #include "test_range.h" 9 10 struct MoveOnlyView : std::ranges::view_base { 11 int *ptr_; 12 MoveOnlyViewMoveOnlyView13 constexpr explicit MoveOnlyView(int* ptr) : ptr_(ptr) {} 14 MoveOnlyView(MoveOnlyView&&) = default; 15 MoveOnlyView& operator=(MoveOnlyView&&) = default; 16 beginMoveOnlyView17 constexpr int* begin() const {return ptr_;} endMoveOnlyView18 constexpr sentinel_wrapper<int*> end() const {return sentinel_wrapper<int*>{ptr_ + 8};} 19 }; 20 static_assert( std::ranges::view<MoveOnlyView>); 21 static_assert( std::ranges::contiguous_range<MoveOnlyView>); 22 static_assert(!std::copyable<MoveOnlyView>); 23 24 struct CopyableView : std::ranges::view_base { 25 int *ptr_; CopyableViewCopyableView26 constexpr explicit CopyableView(int* ptr) : ptr_(ptr) {} 27 beginCopyableView28 constexpr int* begin() const {return ptr_;} endCopyableView29 constexpr sentinel_wrapper<int*> end() const {return sentinel_wrapper<int*>{ptr_ + 8};} 30 }; 31 static_assert(std::ranges::view<CopyableView>); 32 static_assert(std::ranges::contiguous_range<CopyableView>); 33 static_assert(std::copyable<CopyableView>); 34 35 using ForwardIter = forward_iterator<int*>; 36 struct SizedForwardView : std::ranges::view_base { 37 int *ptr_; SizedForwardViewSizedForwardView38 constexpr explicit SizedForwardView(int* ptr) : ptr_(ptr) {} beginSizedForwardView39 constexpr auto begin() const { return ForwardIter(ptr_); } endSizedForwardView40 constexpr auto end() const { return sized_sentinel<ForwardIter>(ForwardIter(ptr_ + 8)); } 41 }; 42 static_assert(std::ranges::view<SizedForwardView>); 43 static_assert(std::ranges::forward_range<SizedForwardView>); 44 static_assert(std::ranges::sized_range<SizedForwardView>); 45 46 using RandomAccessIter = random_access_iterator<int*>; 47 struct SizedRandomAccessView : std::ranges::view_base { 48 int *ptr_; SizedRandomAccessViewSizedRandomAccessView49 constexpr explicit SizedRandomAccessView(int* ptr) : ptr_(ptr) {} beginSizedRandomAccessView50 constexpr auto begin() const { return RandomAccessIter(ptr_); } endSizedRandomAccessView51 constexpr auto end() const { return sized_sentinel<RandomAccessIter>(RandomAccessIter(ptr_ + 8)); } 52 }; 53 static_assert(std::ranges::view<SizedRandomAccessView>); 54 static_assert(std::ranges::random_access_range<SizedRandomAccessView>); 55 static_assert(std::ranges::sized_range<SizedRandomAccessView>); 56 57 struct View : std::ranges::view_base { ViewView58 constexpr explicit View(int* b, int* e) : begin_(b), end_(e) { } 59 beginView60 constexpr int* begin() const { return begin_; } endView61 constexpr int* end() const { return end_; } 62 63 private: 64 int* begin_; 65 int* end_; 66 }; 67 68 template <template <class...> typename Iter, bool Simple, bool Sized> 69 struct CommonInputView : std::ranges::view_base { CommonInputViewCommonInputView70 constexpr explicit CommonInputView(int* b, int* e) : begin_(b), end_(e) {} 71 beginCommonInputView72 constexpr Iter<int*> begin() const { return Iter<int*>(begin_); } endCommonInputView73 constexpr Iter<int*> end() const { return Iter<int*>(end_); } 74 beginCommonInputView75 constexpr Iter<const int*> begin() 76 requires(!Simple) 77 { 78 return Iter<const int*>(begin_); 79 } endCommonInputView80 constexpr Iter<const int*> end() 81 requires(!Simple) 82 { 83 return Iter<const int*>(end_); 84 } 85 sizeCommonInputView86 constexpr auto size() const 87 requires Sized 88 { 89 return end_ - begin_; 90 } 91 92 private: 93 int* begin_; 94 int* end_; 95 }; 96 97 using NonSimpleNonSizedView = CommonInputView<common_input_iterator, /*Simple=*/false, /*Sized=*/false>; 98 static_assert(std::ranges::view<NonSimpleNonSizedView>); 99 static_assert(!simple_view<NonSimpleNonSizedView>); 100 static_assert(!std::ranges::sized_range<NonSimpleNonSizedView>); 101 102 using SimpleViewNonSized = CommonInputView<common_input_iterator, /*Simple=*/true, /*Sized=*/false>; 103 static_assert(std::ranges::view<SimpleViewNonSized>); 104 static_assert(simple_view<SimpleViewNonSized>); 105 static_assert(!std::ranges::sized_range<SimpleViewNonSized>); 106 107 using NonSimpleSizedView = CommonInputView<common_input_iterator, /*Simple=*/false, /*Sized=*/true>; 108 static_assert(std::ranges::view<NonSimpleSizedView>); 109 static_assert(!simple_view<NonSimpleSizedView>); 110 static_assert(std::ranges::sized_range<NonSimpleSizedView>); 111 112 using NonSimpleSizedRandomView = CommonInputView<random_access_iterator, /*Simple=*/false, /*Sized=*/true>; 113 static_assert(std::ranges::view<NonSimpleSizedRandomView>); 114 static_assert(!simple_view<NonSimpleSizedRandomView>); 115 static_assert(std::ranges::sized_range<NonSimpleSizedRandomView>); 116 static_assert(std::ranges::random_access_range<NonSimpleSizedRandomView>); 117 118 #endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TAKE_TYPES_H 119