enforce_random_access.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/range/views/detail.hpp>
#include <seqan3/range/detail/inherited_iterator_base.hpp>
#include <seqan3/range/concept.hpp>
#include <seqan3/std/iterator>
#include <seqan3/std/ranges>
 
namespace seqan3::detail
{
 
// ============================================================================
//  view_pseudo_random_access
// ============================================================================
 
template <std::ranges::view urng_t>
    requires pseudo_random_access_range<urng_t>
class view_enforce_random_access : public ranges::view_interface<view_enforce_random_access<urng_t>>
{
private:
 
    // Iterator declaration.
    template <typename underlying_iter_t>
    class enforced_random_access_iterator;
 
public:
 
    constexpr view_enforce_random_access() = default; 
    constexpr view_enforce_random_access(view_enforce_random_access const &) = default; 
    constexpr view_enforce_random_access(view_enforce_random_access &&) = default; 
    constexpr view_enforce_random_access & operator=(view_enforce_random_access const &) = default; 
    constexpr view_enforce_random_access & operator=(view_enforce_random_access &&) = default; 
    ~view_enforce_random_access() = default; 
 
    explicit constexpr view_enforce_random_access(urng_t range) : urng{std::move(range)}
    {}
 
    template <typename viewable_rng_t>
     requires !std::same_as<remove_cvref_t<viewable_rng_t>, view_enforce_random_access> &&
              std::ranges::viewable_range<viewable_rng_t> &&
              std::constructible_from<urng_t, ranges::ref_view<std::remove_reference_t<viewable_rng_t>>>
    explicit constexpr view_enforce_random_access(viewable_rng_t range) :
        view_enforce_random_access{std::views::all(range)}
    {}
 
    constexpr auto begin() noexcept
    {
        return enforced_random_access_iterator<decltype(std::ranges::begin(urng))>{std::ranges::begin(urng)};
    }
 
    constexpr auto begin() const noexcept
        requires const_iterable_range<urng_t>
    {
        return enforced_random_access_iterator<decltype(std::ranges::cbegin(urng))>{std::ranges::cbegin(urng)};
    }
 
    constexpr auto cbegin() const noexcept
        requires const_iterable_range<urng_t>
    {
        return begin();
    }
 
    constexpr auto end() noexcept
    {
        if constexpr (std::ranges::common_range<urng_t>)
            return enforced_random_access_iterator<decltype(std::ranges::end(urng))>{std::ranges::end(urng)};
        else
            return urng.end();
    }
 
    constexpr auto end() const noexcept
        requires const_iterable_range<urng_t>
    {
        if constexpr (std::ranges::common_range<urng_t>)
            return enforced_random_access_iterator<decltype(std::ranges::cend(urng))>{std::ranges::cend(urng)};
        else
            return std::ranges::cend(urng);
    }
 
    constexpr auto cend() const noexcept
        requires const_iterable_range<urng_t>
    {
        return end();
    }
 
    urng_t urng; 
};
 
template <std::ranges::view urng_t>
    requires pseudo_random_access_range<urng_t>
template <typename underlying_iter_t>
class view_enforce_random_access<urng_t>::enforced_random_access_iterator :
    public inherited_iterator_base<enforced_random_access_iterator<underlying_iter_t>, underlying_iter_t>
{
private:
    using base_t = inherited_iterator_base<enforced_random_access_iterator<underlying_iter_t>, underlying_iter_t>;
 
public:
 
    using iterator_category = std::random_access_iterator_tag;
 
    // Importing base's constructors.
    using base_t::base_t;
    constexpr enforced_random_access_iterator() = default;
    constexpr enforced_random_access_iterator(enforced_random_access_iterator const &) = default;
    constexpr enforced_random_access_iterator(enforced_random_access_iterator &&) = default;
    constexpr enforced_random_access_iterator & operator=(enforced_random_access_iterator const &) = default;
    constexpr enforced_random_access_iterator & operator=(enforced_random_access_iterator &&) = default;
    ~enforced_random_access_iterator() = default;
 
    // Importing base's equality operators
    using base_t::operator==;
    using base_t::operator!=;
    friend constexpr bool operator==(enforced_random_access_iterator const & lhs,
                                     std::ranges::sentinel_t<urng_t> const & rhs)
        noexcept(noexcept(std::declval<underlying_iter_t const &>() ==
                          std::declval<std::ranges::sentinel_t<urng_t> const &>()))
    {
        return static_cast<underlying_iter_t const &>(lhs) == rhs;
    }
 
    friend constexpr bool operator==(std::ranges::sentinel_t<urng_t> const & lhs,
                                     enforced_random_access_iterator const & rhs)
        noexcept(noexcept(std::declval<underlying_iter_t const &>() ==
                          std::declval<std::ranges::sentinel_t<urng_t> const &>()))
    {
        return rhs == lhs;
    }
 
    friend constexpr bool operator!=(enforced_random_access_iterator const & lhs,
                                     std::ranges::sentinel_t<urng_t> const & rhs)
        noexcept(noexcept(std::declval<underlying_iter_t const &>() !=
                          std::declval<std::ranges::sentinel_t<urng_t> const &>()))
    {
        return !(lhs == rhs);
    }
 
    friend constexpr bool operator!=(std::ranges::sentinel_t<urng_t> const & lhs,
                                     enforced_random_access_iterator const & rhs)
        noexcept(noexcept(std::declval<underlying_iter_t const &>() !=
                          std::declval<std::ranges::sentinel_t<urng_t> const &>()))
    {
        return rhs != lhs;
    }
 
    // Import operator from base.
    using base_t::operator-;
 
    constexpr typename base_t::difference_type operator-(std::ranges::sentinel_t<urng_t> const & rhs) const
        noexcept(noexcept(std::declval<underlying_iter_t const &>() -
                          std::declval<std::ranges::sentinel_t<urng_t> const &>()))
        requires std::sized_sentinel_for<std::ranges::sentinel_t<urng_t>, underlying_iter_t>
    {
        return static_cast<underlying_iter_t const &>(*this) - rhs;
    }
 
    constexpr friend typename base_t::difference_type operator-(std::ranges::sentinel_t<urng_t> const & lhs,
                                                                enforced_random_access_iterator const & rhs)
        noexcept(noexcept(std::declval<std::ranges::sentinel_t<urng_t> const &>() -
                          std::declval<underlying_iter_t const &>()))
        requires std::sized_sentinel_for<std::ranges::sentinel_t<urng_t>, underlying_iter_t>
    {
        return lhs - static_cast<underlying_iter_t const &>(rhs);
    }
};
 
template <std::ranges::viewable_range rng_t>
view_enforce_random_access(rng_t &&) -> view_enforce_random_access<std::ranges::all_view<rng_t>>;
 
// ============================================================================
//  pseudo_random_access_fn (adaptor definition)
// ============================================================================
 
struct pseudo_random_access_fn : public adaptor_base<pseudo_random_access_fn>
{
private:
    using base_t = adaptor_base<pseudo_random_access_fn>;
 
public:
    using base_t::base_t;
 
private:
    friend base_t;
 
    template <std::ranges::viewable_range urng_t>
    static constexpr auto impl(urng_t && urange)
    {
        static_assert(std::ranges::random_access_range<urng_t> || pseudo_random_access_range<urng_t>,
                      "The adapted range must either model std::ranges::random_access_range or must be "
                      "a specific SeqAn range type that supports pseudo random access.");
        static_assert(std::ranges::forward_range<urng_t>,
                      "The underlying range must model std::ranges::forward_range.");
 
        if constexpr (std::ranges::random_access_range<urng_t>)
        { // Nothing to do, just return as ref_view or original view.
            return std::views::all(std::forward<urng_t>(urange));
        }
        else
        { // Get a subrange using the random access iterators of the container.
            return view_enforce_random_access{std::forward<urng_t>(urange)};
        }
    }
};
 
}  // namespace seqan3::detail
 
namespace seqan3::views
{
 
inline constexpr auto enforce_random_access = detail::pseudo_random_access_fn{};
} // namespace seqan3::views