18namespace sequoia::utilities
22 { --i } -> std::same_as<I&>;
23 { i-- } -> std::convertible_to<I>;
27 concept steppable =
requires(I i,
const I j,
const std::iter_difference_t<I> n) {
28 { i += n } -> std::same_as<I&>;
29 { j + n } -> std::convertible_to<I>;
30 { n + j } -> std::convertible_to<I>;
31 { i -= n } -> std::same_as<I&>;
32 { j - n } -> std::convertible_to<I>;
37 template<
class Policy>
43 decltype(
auto) get(I i)
const
44 requires requires {
static_cast<const Policy&
>(*this).get(i); }
46 return Policy::get(i);
51 template<
class Policy,
class Iterator>
53 typename Policy::value_type;
54 typename Policy::reference;
56 { agg.get(i) } -> std::same_as<typename Policy::reference>;
59 template<
class Policy1,
class Policy2>
60 inline constexpr bool consistent_policies_v{
66 template<
class Iterator, dereference_policy_for<Iterator> Deref>
72 template<
class Iterator, dereference_policy_for<Iterator> Deref>
73 requires requires {
typename Deref::pointer; }
76 using type =
typename Deref::pointer;
79 template<
class Iterator, dereference_policy_for<Iterator> Deref>
80 using pointer_type_t =
typename pointer_type<Iterator, Deref>::type;
87 template<
class Iterator, dereference_policy_for<Iterator> Deref>
90 template<
class Iterator, dereference_policy_for<Iterator> Deref>
91 requires has_difference_type<Deref>
94 using type =
typename Deref::difference_type;
97 template<
class Iterator, dereference_policy_for<Iterator> Deref>
98 requires (!has_difference_type<Deref> && std::input_or_output_iterator<Iterator>)
101 using type =
typename std::iterator_traits<Iterator>::difference_type;
104 template<
class Iterator, dereference_policy_for<Iterator> Deref>
105 using difference_type_t =
typename difference_type<Iterator, Deref>::type;
116 requires std::input_or_output_iterator<I>
119 using type = std::iter_value_t<I>;
123 requires (!std::input_or_output_iterator<T> && has_value_type_v<T>)
126 using type =
typename T::value_type;
130 using value_type_t =
typename value_type<T>::type;
144 requires std::input_or_output_iterator<I>
147 using type = std::iter_reference_t<I>;
151 requires (!std::input_or_output_iterator<T> && has_reference_type<T>)
154 using type =
typename T::reference;
158 using reference_type_t =
typename reference_type<T>::type;
179 template<std::input_or_output_iterator Iterator,
class AuxiliaryDataPolicy=null_data_policy>
182 using base_iterator_type = Iterator;
183 using auxiliary_data_policy = AuxiliaryDataPolicy;
185 using value_type =
typename std::iterator_traits<Iterator>::value_type;
186 using reference =
typename std::iterator_traits<Iterator>::reference;
187 using pointer =
typename std::iterator_traits<Iterator>::pointer;
189 template<
class... Args>
192 : AuxiliaryDataPolicy{std::forward<Args>(args)...}
198 constexpr static reference get(Iterator i) {
return *i; }
201 constexpr static pointer get_ptr(Iterator i) {
return &*i; }
214 template<
class Iterator, dereference_policy_for<Iterator> DereferencePolicy>
215 inline constexpr bool has_sensible_semantics{
216 ( std::indirectly_writable<reference_type_t<Iterator>, value_type_t<Iterator>>
217 && std::indirectly_writable<reference_type_t<DereferencePolicy>, value_type_t<DereferencePolicy>>)
218 || ( !std::indirectly_writable<reference_type_t<Iterator>, value_type_t<Iterator>>
219 && !std::indirectly_writable<reference_type_t<DereferencePolicy>, value_type_t<DereferencePolicy>>)
231 template<
class Iterator, dereference_policy_for<Iterator> DereferencePolicy>
232 requires has_sensible_semantics<Iterator, DereferencePolicy>
236 using base_iterator_type = Iterator;
237 using dereference_policy_type = DereferencePolicy;
239 using value_type =
typename DereferencePolicy::value_type;
240 using reference =
typename DereferencePolicy::reference;
241 using difference_type = difference_type_t<Iterator, DereferencePolicy>;
242 using pointer = pointer_type_t<Iterator, DereferencePolicy>;
246 template<
class Arg,
class... Args>
247 requires (!resolve_to_copy_v<
iterator, Arg, Args...>)
248 constexpr explicit(
sizeof...(Args) == 0)
iterator(Arg&& baseIterArg, Args&&... args)
249 : DereferencePolicy{std::forward<Args>(args)...}
250 , m_BaseIterator{std::forward<Arg>(baseIterArg)}
253 template<
class Iter,
class DerefPol>
254 requires ( !std::is_same_v<Iter, Iterator>
256 && consistent_policies_v<DereferencePolicy, DerefPol>)
258 : DereferencePolicy{
static_cast<const DerefPol&
>(iter)}
259 , m_BaseIterator{iter.base_iterator()}
270 constexpr base_iterator_type base_iterator()
const noexcept {
return m_BaseIterator; }
273 constexpr reference operator*()
const
275 return DereferencePolicy::get(m_BaseIterator);
279 constexpr reference operator[](
const difference_type n)
const
282 return DereferencePolicy::get(m_BaseIterator + n);
285 constexpr pointer operator->()
const
286 requires requires (Iterator i){ DereferencePolicy::get_ptr(i); }
288 return DereferencePolicy::get_ptr(m_BaseIterator);
292 requires std::weakly_incrementable<Iterator>
299 requires std::weakly_incrementable<Iterator>
306 constexpr iterator& operator+=(
const difference_type n)
314 friend constexpr iterator operator+(
const iterator& it,
const difference_type n)
322 friend constexpr iterator operator+(
const difference_type n,
const iterator& it)
331 --m_BaseIterator;
return *
this;
342 constexpr iterator& operator-=(
const difference_type n)
350 friend constexpr iterator operator-(
const iterator& it,
const difference_type n)
358 friend constexpr difference_type operator-(
const iterator& lhs,
const iterator& rhs)
361 return lhs.base_iterator() - rhs.base_iterator();
365 friend constexpr bool operator==(
const iterator& lhs,
const iterator& rhs)
noexcept
367 return lhs.m_BaseIterator == rhs.m_BaseIterator;
371 friend constexpr auto operator<=>(
const iterator& lhs,
const iterator& rhs)
noexcept
373 return lhs.m_BaseIterator <=> rhs.m_BaseIterator;
376 Iterator m_BaseIterator{};
constexpr bool has_reference_type
Detects reference_type.
Definition: Iterator.hpp:135
constexpr bool has_difference_type
Detects difference_type.
Definition: Iterator.hpp:85
Traits which are sufficiently general to appear in the sequoia namespace.
An iterator with policies controlling dereferencing and auxiliary data.
Definition: Iterator.hpp:234
A concept similar to std::constructible_from, but which considers braced-init.
Definition: Concepts.hpp:75
Definition: Iterator.hpp:21
Definition: Iterator.hpp:52
Definition: Iterator.hpp:27
Definition: Iterator.hpp:88
Definition: Iterator.hpp:181
Definition: Iterator.hpp:39
Policy representing absence of additional data carried by theidentity_dereference_policy
Definition: Iterator.hpp:163
Detects pointer_type.
Definition: Iterator.hpp:68
Definition: Iterator.hpp:139
Detects value_type.
Definition: Iterator.hpp:111