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#ifndef _LIBCPP___ITERATOR_CPP17_ITERATOR_CONCEPTS_H 10#define _LIBCPP___ITERATOR_CPP17_ITERATOR_CONCEPTS_H 11 12#include <__concepts/boolean_testable.h> 13#include <__concepts/convertible_to.h> 14#include <__concepts/same_as.h> 15#include <__config> 16#include <__iterator/iterator_traits.h> 17#include <__type_traits/is_convertible.h> 18#include <__type_traits/is_copy_constructible.h> 19#include <__type_traits/is_default_constructible.h> 20#include <__type_traits/is_move_constructible.h> 21#include <__type_traits/is_signed.h> 22#include <__type_traits/is_void.h> 23#include <__utility/as_const.h> 24#include <__utility/forward.h> 25#include <__utility/move.h> 26#include <__utility/swap.h> 27 28#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 29# pragma GCC system_header 30#endif 31 32_LIBCPP_PUSH_MACROS 33#include <__undef_macros> 34 35#if _LIBCPP_STD_VER >= 20 36 37_LIBCPP_BEGIN_NAMESPACE_STD 38 39template <class _Tp> 40concept __cpp17_move_constructible = is_move_constructible_v<_Tp>; 41 42template <class _Tp> 43concept __cpp17_copy_constructible = __cpp17_move_constructible<_Tp> && is_copy_constructible_v<_Tp>; 44 45template <class _Tp> 46concept __cpp17_move_assignable = requires(_Tp __lhs, _Tp __rhs) { 47 { __lhs = std::move(__rhs) } -> same_as<_Tp&>; 48}; 49 50template <class _Tp> 51concept __cpp17_copy_assignable = __cpp17_move_assignable<_Tp> && requires(_Tp __lhs, _Tp __rhs) { 52 { __lhs = __rhs } -> same_as<_Tp&>; 53 { __lhs = std::as_const(__rhs) } -> same_as<_Tp&>; 54}; 55 56template <class _Tp> 57concept __cpp17_destructible = requires(_Tp __v) { __v.~_Tp(); }; 58 59template <class _Tp> 60concept __cpp17_equality_comparable = requires(_Tp __lhs, _Tp __rhs) { 61 { __lhs == __rhs } -> __boolean_testable; 62 { std::as_const(__lhs) == __rhs } -> __boolean_testable; 63 { __lhs == std::as_const(__rhs) } -> __boolean_testable; 64 { std::as_const(__lhs) == std::as_const(__rhs) } -> __boolean_testable; 65}; 66 67template <class _Tp> 68concept __cpp17_default_constructible = is_default_constructible_v<_Tp>; 69 70template <class _Iter> 71concept __cpp17_iterator = 72 __cpp17_copy_constructible<_Iter> && __cpp17_copy_assignable<_Iter> && __cpp17_destructible<_Iter> && 73 (is_signed_v<__iter_diff_t<_Iter>> || is_void_v<__iter_diff_t<_Iter>>)&&requires(_Iter __iter) { 74 { *__iter }; 75 { ++__iter } -> same_as<_Iter&>; 76 }; 77 78template <class _Iter> 79concept __cpp17_input_iterator = 80 __cpp17_iterator<_Iter> && __cpp17_equality_comparable<_Iter> && requires(_Iter __lhs, _Iter __rhs) { 81 { __lhs != __rhs } -> __boolean_testable; 82 { std::as_const(__lhs) != __rhs } -> __boolean_testable; 83 { __lhs != std::as_const(__rhs) } -> __boolean_testable; 84 { std::as_const(__lhs) != std::as_const(__rhs) } -> __boolean_testable; 85 86 { *__lhs } -> same_as<__iter_reference<_Iter>>; 87 { *std::as_const(__lhs) } -> same_as<__iter_reference<_Iter>>; 88 89 { ++__lhs } -> same_as<_Iter&>; 90 { (void)__lhs++ }; 91 { *__lhs++ }; 92 }; 93 94template <class _Iter, class _WriteTo> 95concept __cpp17_output_iterator = __cpp17_iterator<_Iter> && requires(_Iter __iter, _WriteTo __write) { 96 { *__iter = std::forward<_WriteTo>(__write) }; 97 { ++__iter } -> same_as<_Iter&>; 98 { __iter++ } -> convertible_to<const _Iter&>; 99 { *__iter++ = std::forward<_WriteTo>(__write) }; 100}; 101 102template <class _Iter> 103concept __cpp17_forward_iterator = 104 __cpp17_input_iterator<_Iter> && __cpp17_default_constructible<_Iter> && requires(_Iter __iter) { 105 { __iter++ } -> convertible_to<const _Iter&>; 106 { *__iter++ } -> same_as<__iter_reference<_Iter>>; 107 }; 108 109template <class _Iter> 110concept __cpp17_bidirectional_iterator = __cpp17_forward_iterator<_Iter> && requires(_Iter __iter) { 111 { --__iter } -> same_as<_Iter&>; 112 { __iter-- } -> convertible_to<const _Iter&>; 113 { *__iter-- } -> same_as<__iter_reference<_Iter>>; 114}; 115 116template <class _Iter> 117concept __cpp17_random_access_iterator = 118 __cpp17_bidirectional_iterator<_Iter> && requires(_Iter __iter, __iter_diff_t<_Iter> __n) { 119 { __iter += __n } -> same_as<_Iter&>; 120 121 { __iter + __n } -> same_as<_Iter>; 122 { __n + __iter } -> same_as<_Iter>; 123 { std::as_const(__iter) + __n } -> same_as<_Iter>; 124 { __n + std::as_const(__iter) } -> same_as<_Iter>; 125 126 { __iter -= __n } -> same_as<_Iter&>; 127 { __iter - __n } -> same_as<_Iter>; 128 { std::as_const(__iter) - __n } -> same_as<_Iter>; 129 130 { __iter - __iter } -> same_as<__iter_diff_t<_Iter>>; 131 { std::as_const(__iter) - __iter } -> same_as<__iter_diff_t<_Iter>>; 132 { __iter - std::as_const(__iter) } -> same_as<__iter_diff_t<_Iter>>; 133 { std::as_const(__iter) - std::as_const(__iter) } -> same_as<__iter_diff_t<_Iter>>; 134 135 { __iter[__n] } -> convertible_to<__iter_reference<_Iter>>; 136 { std::as_const(__iter)[__n] } -> convertible_to<__iter_reference<_Iter>>; 137 138 { __iter < __iter } -> __boolean_testable; 139 { std::as_const(__iter) < __iter } -> __boolean_testable; 140 { __iter < std::as_const(__iter) } -> __boolean_testable; 141 { std::as_const(__iter) < std::as_const(__iter) } -> __boolean_testable; 142 143 { __iter > __iter } -> __boolean_testable; 144 { std::as_const(__iter) > __iter } -> __boolean_testable; 145 { __iter > std::as_const(__iter) } -> __boolean_testable; 146 { std::as_const(__iter) > std::as_const(__iter) } -> __boolean_testable; 147 148 { __iter >= __iter } -> __boolean_testable; 149 { std::as_const(__iter) >= __iter } -> __boolean_testable; 150 { __iter >= std::as_const(__iter) } -> __boolean_testable; 151 { std::as_const(__iter) >= std::as_const(__iter) } -> __boolean_testable; 152 153 { __iter <= __iter } -> __boolean_testable; 154 { std::as_const(__iter) <= __iter } -> __boolean_testable; 155 { __iter <= std::as_const(__iter) } -> __boolean_testable; 156 { std::as_const(__iter) <= std::as_const(__iter) } -> __boolean_testable; 157 }; 158 159_LIBCPP_END_NAMESPACE_STD 160 161# ifndef _LIBCPP_DISABLE_ITERATOR_CHECKS 162# define _LIBCPP_REQUIRE_CPP17_INPUT_ITERATOR(iter_t) static_assert(::std::__cpp17_input_iterator<iter_t>); 163# define _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(iter_t, write_t) \ 164 static_assert(::std::__cpp17_output_iterator<iter_t, write_t>); 165# define _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(iter_t) static_assert(::std::__cpp17_forward_iterator<iter_t>); 166# define _LIBCPP_REQUIRE_CPP17_BIDIRECTIONAL_ITERATOR(iter_t) \ 167 static_assert(::std::__cpp17_bidirectional_iterator<iter_t>); 168# define _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(iter_t) \ 169 static_assert(::std::__cpp17_random_access_iterator<iter_t>); 170# else 171# define _LIBCPP_REQUIRE_CPP17_INPUT_ITERATOR(iter_t) 172# define _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(iter_t, write_t) 173# define _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(iter_t) 174# define _LIBCPP_REQUIRE_CPP17_BIDIRECTIONAL_ITERATOR(iter_t) 175# define _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(iter_t) 176# endif 177 178#else // _LIBCPP_STD_VER >= 20 179 180# define _LIBCPP_REQUIRE_CPP17_INPUT_ITERATOR(iter_t) 181# define _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(iter_t, write_t) 182# define _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(iter_t) 183# define _LIBCPP_REQUIRE_CPP17_BIDIRECTIONAL_ITERATOR(iter_t) 184# define _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(iter_t) 185 186#endif // _LIBCPP_STD_VER >= 20 187 188_LIBCPP_POP_MACROS 189 190#endif // _LIBCPP___ITERATOR_CPP17_ITERATOR_CONCEPTS_H 191