27namespace seqan3::detail
47template <std::ranges::view urng_t,
typename fun_t,
bool or_throw,
bool and_consume>
48class view_take_until :
public std::ranges::view_interface<view_take_until<urng_t, fun_t, or_throw, and_consume>>
51 static_assert(std::invocable<fun_t, std::ranges::range_reference_t<urng_t>>,
52 "The functor type for detail::take_until must model"
53 "std::invocable<fun_t, std::ranges::range_reference_t<urng_t>>.");
54 static_assert(std::convertible_to<std::invoke_result_t<fun_t &&, std::ranges::range_reference_t<urng_t>>,
bool>,
55 "The result type of the functor for detail::take_until must be a boolean.");
61 copyable_wrapper_t<fun_t> fun;
64 static constexpr bool const_iterable =
69 template <
bool const_range>
70 using basic_iterator = seqan3::detail::maybe_const_iterator_t<const_range, urng_t>;
74 template <
bool const_range>
79 template <
bool const_range>
80 class basic_consume_iterator;
84 template <
bool const_range>
85 using basic_consume_sentinel = std::default_sentinel_t;
91 view_take_until() =
default;
92 constexpr view_take_until(view_take_until
const & rhs) =
default;
93 constexpr view_take_until(view_take_until && rhs) =
default;
94 constexpr view_take_until & operator=(view_take_until
const & rhs) =
default;
95 constexpr view_take_until & operator=(view_take_until && rhs) =
default;
96 ~view_take_until() =
default;
102 view_take_until(urng_t && _urange, fun_t && _fun) :
112 template <std::ranges::viewable_range rng_t>
113 requires std::constructible_from<urng_t, std::views::all_t<rng_t>>
114 view_take_until(rng_t && _urange, fun_t && _fun) :
135 auto begin() noexcept
137 if constexpr (and_consume && !std::ranges::forward_range<urng_t>)
138 return basic_consume_iterator<false>{
std::ranges::begin(urange), fun, std::ranges::end(urange)};
144 auto begin() const noexcept
145 requires const_iterable
147 if constexpr (and_consume && !std::ranges::forward_range<urng_t const>)
148 return basic_consume_iterator<true>{
std::ranges::cbegin(urange), fun, std::ranges::cend(urange)};
168 if constexpr (and_consume && !std::ranges::forward_range<urng_t>)
169 return basic_consume_sentinel<false>{};
171 return basic_sentinel<false>{std::ranges::end(urange), fun};
175 auto end() const noexcept
176 requires const_iterable
178 if constexpr (and_consume && !std::ranges::forward_range<urng_t const>)
179 return basic_consume_sentinel<true>{};
181 return basic_sentinel<true>{std::ranges::end(urange), fun};
188template <
typename urng_t,
typename fun_t,
bool or_throw = false,
bool and_consume = false>
189view_take_until(urng_t &&, fun_t &&) -> view_take_until<std::views::all_t<urng_t>, fun_t, or_throw, and_consume>;
191template <std::ranges::view urng_t,
typename fun_t,
bool or_throw,
bool and_consume>
192template <
bool const_range>
193class view_take_until<urng_t, fun_t, or_throw, and_consume>::basic_consume_iterator :
194 public inherited_iterator_base<basic_consume_iterator<const_range>,
195 seqan3::detail::maybe_const_iterator_t<const_range, urng_t>>
199 using underlying_iterator_t = seqan3::detail::maybe_const_iterator_t<const_range, urng_t>;
201 using base_t = inherited_iterator_base<basic_consume_iterator, underlying_iterator_t>;
204 copyable_wrapper_t<fun_t>
const * fun{
nullptr};
207 using underlying_sentinel_t = seqan3::detail::maybe_const_sentinel_t<const_range, urng_t>;
210 underlying_sentinel_t underlying_sentinel;
213 bool at_end_gracefully =
false;
220 constexpr basic_consume_iterator() =
default;
221 constexpr basic_consume_iterator(basic_consume_iterator
const & rhs) =
default;
222 constexpr basic_consume_iterator(basic_consume_iterator && rhs) =
default;
223 constexpr basic_consume_iterator & operator=(basic_consume_iterator
const & rhs) =
default;
224 constexpr basic_consume_iterator & operator=(basic_consume_iterator && rhs) =
default;
225 ~basic_consume_iterator() =
default;
228 basic_consume_iterator(underlying_iterator_t it,
229 copyable_wrapper_t<fun_t>
const & _fun,
230 underlying_sentinel_t sen)
noexcept(
noexcept(base_t{it})) :
231 base_t{std::move(it)},
233 underlying_sentinel{std::move(sen)}
235 if ((this->base() != underlying_sentinel) && fun->operator()(**
this))
237 at_end_gracefully =
true;
250 using pointer = detail::iter_pointer_t<underlying_iterator_t>;
259 basic_consume_iterator & operator++() noexcept(noexcept(++
std::declval<base_t &>()) && noexcept(
260 std::declval<underlying_iterator_t &>()
261 !=
std::declval<underlying_sentinel_t &>()) && noexcept(fun->operator()(
std::declval<reference>())))
263 base_t::operator++();
265 while ((this->base() != underlying_sentinel) && fun->operator()(**
this))
267 at_end_gracefully =
true;
268 base_t::operator++();
275 decltype(
auto)
operator++(
int)
noexcept(
noexcept(++std::declval<basic_consume_iterator &>())
276 && (std::same_as<
decltype(std::declval<underlying_iterator_t &>()++),
void>
277 || std::is_nothrow_copy_constructible_v<basic_consume_iterator>))
280 if constexpr (std::same_as<decltype(std::declval<underlying_iterator_t &>()++),
void>)
286 basic_consume_iterator cpy{*
this};
297 bool operator==(basic_consume_sentinel<const_range>
const &)
const noexcept(!or_throw &&
noexcept(
298 std::declval<underlying_iterator_t &>()
299 != std::declval<underlying_sentinel_t &>()) &&
noexcept(fun->operator()(std::declval<reference>())))
301 if (at_end_gracefully)
304 if (this->base() == underlying_sentinel)
306 if constexpr (or_throw)
307 throw unexpected_end_of_input{
"Reached end of input before functor evaluated to true."};
312 return fun->operator()(**this);
316 friend bool operator==(basic_consume_sentinel<const_range>
const & lhs,
317 basic_consume_iterator
const & rhs)
noexcept(
noexcept(rhs == lhs))
323 bool operator!=(basic_consume_sentinel<const_range>
const & rhs)
const
324 noexcept(
noexcept(std::declval<basic_consume_iterator &>() == rhs))
326 return !(*
this == rhs);
330 friend bool operator!=(basic_consume_sentinel<const_range>
const & lhs,
331 basic_consume_iterator
const & rhs)
noexcept(
noexcept(rhs != lhs))
338template <std::ranges::view urng_t,
typename fun_t,
bool or_throw,
bool and_consume>
339template <
bool const_range>
340class view_take_until<urng_t, fun_t, or_throw, and_consume>::basic_sentinel
344 using underlying_sentinel_t = seqan3::detail::maybe_const_sentinel_t<const_range, urng_t>;
347 underlying_sentinel_t underlying_sentinel{};
350 copyable_wrapper_t<fun_t>
const * fun{
nullptr};
356 basic_sentinel() =
default;
357 basic_sentinel(basic_sentinel
const &) =
default;
358 basic_sentinel(basic_sentinel &&) =
default;
359 basic_sentinel & operator=(basic_sentinel
const &) =
default;
360 basic_sentinel & operator=(basic_sentinel &&) =
default;
361 ~basic_sentinel() =
default;
367 explicit basic_sentinel(underlying_sentinel_t underlying_sentinel, copyable_wrapper_t<fun_t>
const & _fun) :
368 underlying_sentinel{
std::
move(underlying_sentinel)},
373 basic_sentinel(basic_sentinel<!const_range> other)
374 requires const_range && std::convertible_to<std::ranges::sentinel_t<urng_t>, underlying_sentinel_t>
375 : underlying_sentinel{std::move(other.underlying_sentinel)}, fun{other.fun}
384 friend bool operator==(basic_iterator<const_range>
const & lhs, basic_sentinel
const & rhs)
387 if (lhs == rhs.underlying_sentinel)
389 if constexpr (or_throw)
390 throw unexpected_end_of_input{
"Reached end of input before functor evaluated to true."};
395 return rhs.fun->operator()(*lhs);
399 friend bool operator==(basic_sentinel
const & lhs, basic_iterator<const_range>
const & rhs)
405 friend bool operator!=(basic_iterator<const_range>
const & lhs, basic_sentinel
const & rhs)
407 return !(lhs == rhs);
411 friend bool operator!=(basic_sentinel
const & lhs, basic_iterator<const_range>
const & rhs)
417 template <
bool other_const_range = !const_range>
418 requires (std::sentinel_for<underlying_sentinel_t, basic_iterator<other_const_range>>)
419 friend bool operator==(basic_iterator<other_const_range>
const & lhs, basic_sentinel
const & rhs)
422 if (lhs == rhs.underlying_sentinel)
424 if constexpr (or_throw)
425 throw unexpected_end_of_input{
"Reached end of input before functor evaluated to true."};
430 return rhs.fun->operator()(*lhs);
434 template <
bool other_const_range = !const_range>
435 requires (std::sentinel_for<underlying_sentinel_t, basic_iterator<other_const_range>>)
436 friend bool operator==(basic_sentinel
const & lhs, basic_iterator<other_const_range>
const & rhs)
442 template <
bool other_const_range = !const_range>
443 requires (std::sentinel_for<underlying_sentinel_t, basic_iterator<other_const_range>>)
444 friend bool operator!=(basic_iterator<other_const_range>
const & lhs, basic_sentinel
const & rhs)
446 return !(lhs == rhs);
450 template <
bool other_const_range = !const_range>
451 requires (std::sentinel_for<underlying_sentinel_t, basic_iterator<other_const_range>>)
452 friend bool operator!=(basic_sentinel
const & lhs, basic_iterator<other_const_range>
const & rhs)
466template <
bool or_throw,
bool and_consume>
470 template <
typename fun_t>
471 constexpr auto operator()(fun_t && fun)
const
473 return adaptor_from_functor{*
this, std::forward<fun_t>(fun)};
483 template <std::ranges::viewable_range urng_t,
typename fun_t>
484 constexpr auto operator()(urng_t && urange, fun_t && fun)
const
486 return view_take_until<std::views::all_t<urng_t>, fun_t, or_throw, and_consume>{
487 std::views::all(std::forward<urng_t>(urange)),
488 std::forward<fun_t>(fun)};
498namespace seqan3::detail
557inline constexpr auto take_until = take_until_fn<false, false>{};
571inline constexpr auto take_until_or_throw = take_until_fn<true, false>{};
585inline constexpr auto take_until_and_consume = take_until_fn<false, true>{};
599inline constexpr auto take_until_or_throw_and_consume = take_until_fn<true, true>{};
Provides seqan3::detail::adaptor_from_functor.
Provides seqan3::detail::copyable_wrapper.
Provides various transformation traits used by the range module.
Provides the seqan3::detail::inherited_iterator_base template.
Specifies requirements of an input range type for which the const version of that type satisfies the ...
Provides exceptions used in the I/O module.
Provides various transformation traits for use on iterators.
SeqAn specific customisations in the standard namespace.
Additional non-standard concepts for ranges.