take_until.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <seqan3/core/semiregular_box.hpp>
#include <seqan3/core/type_traits/iterator.hpp>
#include <seqan3/core/type_traits/range.hpp>
#include <seqan3/core/type_traits/transformation_trait_or.hpp>
#include <seqan3/io/exception.hpp>
#include <seqan3/range/concept.hpp>
#include <seqan3/range/views/detail.hpp>
#include <seqan3/range/detail/inherited_iterator_base.hpp>
#include <seqan3/std/concepts>
#include <seqan3/std/ranges>
#include <seqan3/range/container/concept.hpp>
#include <seqan3/std/algorithm>
#include <seqan3/std/concepts>
#include <seqan3/std/iterator>
#include <seqan3/std/type_traits>
#include <seqan3/std/ranges>
 
namespace seqan3::detail
{
 
// ============================================================================
//  view_take_until
// ============================================================================
 
template <std::ranges::view urng_t, typename fun_t, bool or_throw, bool and_consume>
class view_take_until : public std::ranges::view_interface<view_take_until<urng_t, fun_t, or_throw, and_consume>>
{
private:
 
    static_assert(std::invocable<fun_t, std::ranges::range_reference_t<urng_t>>,
                  "The functor type for views::take_until must model"
                  "std::invocable<fun_t, std::ranges::range_reference_t<urng_t>>.");
    static_assert(std::convertible_to<std::result_of_t<fun_t&&(std::ranges::range_reference_t<urng_t>)>, bool>,
                  "The result type of the functor for views::take_until must be a boolean.");
 
    urng_t urange;
 
    ranges::semiregular_t<fun_t> fun;
 
    static constexpr bool const_iterable = const_iterable_range<urng_t> &&
                                           std::regular_invocable<fun_t, std::ranges::range_reference_t<urng_t>>;
 
    template <typename rng_t>
    class basic_iterator;
 
    template <bool is_const_range>
    class basic_sentinel;
 
    template <typename rng_t>
    class basic_consume_iterator;
 
private:
    using iterator = std::conditional_t<and_consume && !std::ranges::forward_range<urng_t>,
                                        basic_consume_iterator<urng_t>,
                                        basic_iterator<urng_t>>;
 
    using const_iterator = basic_iterator<urng_t const>;
 
public:
    view_take_until()                                                  = default; 
    constexpr view_take_until(view_take_until const & rhs)             = default; 
    constexpr view_take_until(view_take_until && rhs)                  = default; 
    constexpr view_take_until & operator=(view_take_until const & rhs) = default; 
    constexpr view_take_until & operator=(view_take_until && rhs)      = default; 
    ~view_take_until()                                                 = default; 
 
    view_take_until(urng_t _urange, fun_t _fun)
        : urange{std::move(_urange)}, fun{std::forward<fun_t>(_fun)}
    {}
 
    template <std::ranges::viewable_range rng_t>
        requires std::constructible_from<rng_t, std::views::all_t<rng_t>>
    view_take_until(rng_t && _urange, fun_t _fun)
        : view_take_until{std::views::all(std::forward<rng_t>(_urange)), std::move(_fun)}
    {}
 
    iterator begin() noexcept
    {
        return {std::ranges::begin(urange), static_cast<fun_t &>(fun), std::ranges::end(urange)};
    }
 
    const_iterator begin() const noexcept
        requires const_iterable
    {
        return {std::ranges::cbegin(urange), static_cast<fun_t const &>(fun), std::ranges::cend(urange)};
    }
 
    auto end() noexcept
    {
        if constexpr (and_consume && !std::ranges::forward_range<urng_t>)
            return std::ranges::end(urange);
        else
            return basic_sentinel<false>{std::ranges::end(urange), fun};
    }
 
    auto end() const noexcept
        requires const_iterable
    {
        if constexpr (and_consume && !std::ranges::forward_range<urng_t>)
            return std::ranges::cend(urange);
        else
            return basic_sentinel<true>{std::ranges::cend(urange), static_cast<fun_t const &>(fun)};
    }
};
 
template <typename urng_t, typename fun_t, bool or_throw = false, bool and_consume = false>
view_take_until(urng_t &&, fun_t) -> view_take_until<std::views::all_t<urng_t>, fun_t, or_throw, and_consume>;
 
template <std::ranges::view urng_t, typename fun_t, bool or_throw, bool and_consume>
template <typename rng_t>
class view_take_until<urng_t, fun_t, or_throw, and_consume>::basic_iterator :
    public inherited_iterator_base<basic_iterator<rng_t>, std::ranges::iterator_t<rng_t>>
{
private:
    using base_base_t = std::ranges::iterator_t<rng_t>;
    using base_t = inherited_iterator_base<basic_iterator, std::ranges::iterator_t<rng_t>>;
    using sentinel_type = std::ranges::sentinel_t<rng_t>;
    using fun_ref_t = std::conditional_t<std::is_const_v<rng_t>,
                                         std::remove_reference_t<fun_t> const &,
                                         std::remove_reference_t<fun_t> &>;
    seqan3::semiregular_box_t<fun_ref_t> fun;
 
public:
    constexpr basic_iterator() = default; 
    constexpr basic_iterator(basic_iterator const & rhs) = default; 
    constexpr basic_iterator(basic_iterator && rhs) = default; 
    constexpr basic_iterator & operator=(basic_iterator const & rhs) = default; 
    constexpr basic_iterator & operator=(basic_iterator && rhs) = default; 
    ~basic_iterator() = default; 
 
    basic_iterator(base_base_t it) noexcept(noexcept(base_t{it})) :
        base_t{std::move(it)}
    {}
 
    basic_iterator(base_base_t it,
                   fun_ref_t _fun,
                   sentinel_type /*only used by the consuming iterator*/) noexcept(noexcept(base_t{it})) :
        base_t{std::move(it)}, fun{_fun}
    {}
 
    using difference_type = std::iter_difference_t<base_base_t>;
    using value_type = std::iter_value_t<base_base_t>;
    using reference = std::iter_reference_t<base_base_t>;
    using pointer = detail::iter_pointer_t<base_base_t>;
    using iterator_category = detail::iterator_category_tag_t<base_base_t>;
    using iterator_concept = detail::iterator_concept_tag_t<base_base_t>;
 
    base_base_t base() const
        requires std::copy_constructible<base_base_t>
    {
        return *this->this_to_base();
    }
};
 
template <std::ranges::view urng_t, typename fun_t, bool or_throw, bool and_consume>
template <typename rng_t>
class view_take_until<urng_t, fun_t, or_throw, and_consume>::basic_consume_iterator :
    public inherited_iterator_base<basic_consume_iterator<rng_t>, std::ranges::iterator_t<rng_t>>
{
private:
    using base_base_t = std::ranges::iterator_t<rng_t>;
    using base_t = inherited_iterator_base<basic_consume_iterator, std::ranges::iterator_t<rng_t>>;
 
    using fun_ref_t = std::conditional_t<std::is_const_v<rng_t>,
                                         std::remove_reference_t<fun_t> const &,
                                         std::remove_reference_t<fun_t> &>;
    seqan3::semiregular_box_t<fun_ref_t> fun;
 
    using sentinel_type = std::ranges::sentinel_t<rng_t>;
 
    sentinel_type stored_end;
 
    bool at_end_gracefully = false;
 
public:
    constexpr basic_consume_iterator() = default; 
    constexpr basic_consume_iterator(basic_consume_iterator const & rhs) = default; 
    constexpr basic_consume_iterator(basic_consume_iterator && rhs) = default; 
    constexpr basic_consume_iterator & operator=(basic_consume_iterator const & rhs) = default; 
    constexpr basic_consume_iterator & operator=(basic_consume_iterator && rhs) = default; 
    ~basic_consume_iterator() = default; 
 
    basic_consume_iterator(base_base_t it,
                           fun_ref_t _fun,
                           sentinel_type sen) noexcept(noexcept(base_t{it})) :
        base_t{std::move(it)}, fun{_fun}, stored_end{std::move(sen)}
    {
        if ((*this->this_to_base() != stored_end) && fun(**this))
        {
            at_end_gracefully = true;
            ++(*this);
        }
    }
 
    using difference_type = std::iter_difference_t<base_base_t>; 
    using value_type = std::iter_value_t<base_base_t>; 
    using reference = std::iter_reference_t<base_base_t>; 
    using pointer = detail::iter_pointer_t<base_base_t>; 
    using iterator_category = std::input_iterator_tag; 
 
    basic_consume_iterator & operator++()
        noexcept(noexcept(++std::declval<base_t &>()) &&
                 noexcept(std::declval<base_base_t &>() != std::declval<sentinel_type &>()) &&
                 noexcept(fun(std::declval<reference>())))
    {
        base_t::operator++();
 
        while ((*this->this_to_base() != stored_end) && fun(**this))
        {
            at_end_gracefully = true;
            base_t::operator++();
        }
 
        return *this;
    }
 
    basic_consume_iterator operator++(int)
        noexcept(noexcept(++std::declval<basic_consume_iterator &>()) &&
                 std::is_nothrow_copy_constructible_v<basic_consume_iterator>)
    {
        basic_consume_iterator cpy{*this};
        ++(*this);
        return cpy;
    }
 
    bool operator==(sentinel_type const & rhs) const
        noexcept(!or_throw &&
                 noexcept(std::declval<base_base_t &>() != std::declval<sentinel_type &>()) &&
                 noexcept(fun(std::declval<reference>())))
    {
        if (at_end_gracefully)
            return true;
 
        if (*this->this_to_base() == rhs)
        {
            if constexpr (or_throw)
                throw unexpected_end_of_input{"Reached end of input before functor evaluated to true."};
            else
                return true;
        }
 
        return fun(**this);
    }
 
    friend bool operator==(sentinel_type const & lhs, basic_consume_iterator const & rhs)
        noexcept(noexcept(rhs == lhs))
    {
        return rhs == lhs;
    }
 
    bool operator!=(sentinel_type const & rhs) const
        noexcept(noexcept(std::declval<basic_consume_iterator &>() == rhs))
    {
        return !(*this == rhs);
    }
 
    friend bool operator!=(sentinel_type const & lhs, basic_consume_iterator const & rhs)
        noexcept(noexcept(rhs != lhs))
    {
        return rhs != lhs;
    }
};
 
template <std::ranges::view urng_t, typename fun_t, bool or_throw, bool and_consume>
template <bool is_const_range>
class view_take_until<urng_t, fun_t, or_throw, and_consume>::basic_sentinel
{
private:
    using urng_base_type = std::conditional_t<is_const_range, std::add_const_t<urng_t>, urng_t>;
    using urng_sentinel_type = std::ranges::sentinel_t<urng_base_type>;
    using predicate_ref_t = std::conditional_t<is_const_range,
                                               std::remove_reference_t<fun_t> const &,
                                               std::remove_reference_t<fun_t> &>;
 
    urng_sentinel_type urng_sentinel{};
 
    seqan3::semiregular_box_t<predicate_ref_t> predicate{};
 
public:
    basic_sentinel() = default; 
    basic_sentinel(basic_sentinel const &) = default; 
    basic_sentinel(basic_sentinel &&) = default; 
    basic_sentinel & operator=(basic_sentinel const &) = default; 
    basic_sentinel & operator=(basic_sentinel &&) = default; 
    ~basic_sentinel() = default; 
 
    explicit basic_sentinel(urng_sentinel_type urng_sentinel, predicate_ref_t predicate) :
        urng_sentinel{std::move(urng_sentinel)},
        predicate{predicate}
    {}
 
    basic_sentinel(basic_sentinel<!is_const_range> other)
        requires is_const_range && std::convertible_to<std::ranges::sentinel_t<urng_t>, urng_sentinel_type>
        : urng_sentinel{std::move(other.urng_sentinel)},
          predicate{other.predicate}
    {}
 
    template <typename rng_t>
    friend bool operator==(basic_iterator<rng_t> const & lhs, basic_sentinel const & rhs)
    {
        // Actual comparison delegated to lhs base
        if (lhs.base() == rhs.urng_sentinel)
        {
            if constexpr (or_throw)
                throw unexpected_end_of_input{"Reached end of input before functor evaluated to true."};
            else
                return true;
        }
 
        return rhs.predicate(*lhs);
    }
 
    template <typename rng_t>
    friend bool operator==(basic_sentinel const & lhs, basic_iterator<rng_t> const & rhs)
    {
        return rhs == lhs;
    }
 
    template <typename rng_t>
    friend bool operator!=(basic_iterator<rng_t> const & lhs, basic_sentinel const & rhs)
    {
        return !(lhs == rhs);
    }
 
    template <typename rng_t>
    friend bool operator!=(basic_sentinel const & lhs, basic_iterator<rng_t> const & rhs)
    {
        return rhs != lhs;
    }
};
 
// ============================================================================
//  take_until_fn (adaptor definition)
// ============================================================================
 
template <bool or_throw, bool and_consume>
struct take_until_fn
{
    template <typename fun_t>
    constexpr auto operator()(fun_t && fun) const
    {
        return adaptor_from_functor{*this, std::forward<fun_t>(fun)};
    }
 
    template <std::ranges::viewable_range urng_t, typename fun_t>
    constexpr auto operator()(urng_t && urange, fun_t && fun) const
    {
        return view_take_until<std::views::all_t<urng_t>, fun_t, or_throw, and_consume>
        {
            std::views::all(std::forward<urng_t>(urange)),
            std::forward<fun_t>(fun)
        };
    }
};
 
} // namespace seqan3::detail
 
// ============================================================================
//  views::take_until (adaptor instance definition)
// ============================================================================
 
namespace seqan3::views
{
 
inline auto constexpr take_until = detail::take_until_fn<false, false>{};
 
// ============================================================================
//  views::take_until_or_throw (adaptor instance definition)
// ============================================================================
 
inline auto constexpr take_until_or_throw = detail::take_until_fn<true, false>{};
 
// ============================================================================
//  views::take_until_and_consume (adaptor instance definition)
// ============================================================================
 
inline auto constexpr take_until_and_consume = detail::take_until_fn<false, true>{};
 
// ============================================================================
//  views::take_until_or_throw_and_consume (adaptor instance definition)
// ============================================================================
 
inline auto constexpr take_until_or_throw_and_consume = detail::take_until_fn<true, true>{};
 
 
} // namespace seqan3::views