all_view.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2022, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2022, 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 <ranges>
 
#if __cpp_lib_ranges >= 202110L
 
#    include <seqan3/core/platform.hpp>
 
namespace seqan3::detail
{
using std::ranges::owning_view;
using std::ranges::views::all;
using std::ranges::views::all_t;
 
} // namespace seqan3::detail
#else
#    include <seqan3/core/detail/template_inspection.hpp>
#    include <seqan3/core/range/detail/adaptor_base.hpp>
 
namespace seqan3::detail
{
 
template <std::ranges::range rng_t>
    requires std::movable<rng_t> && (!seqan3::detail::is_type_specialisation_of_v<rng_t, std::initializer_list>)
class owning_view : public std::ranges::view_interface<owning_view<rng_t>>
{
private:
    rng_t rng = rng_t();
 
public:
    owning_view()
        requires std::default_initializable<rng_t>
    = default;                                             
    owning_view(owning_view const &) = delete;             
    owning_view & operator=(owning_view const &) = delete; 
    owning_view(owning_view &&) = default;                 
    owning_view & operator=(owning_view &&) = default;     
    ~owning_view() = default;                              
 
    constexpr owning_view(rng_t && r) : rng(std::move(r))
    {}
 
    constexpr rng_t & base() & noexcept
    {
        return rng;
    }
 
    constexpr rng_t const & base() const & noexcept
    {
        return rng;
    }
 
    constexpr rng_t && base() && noexcept
    {
        return std::move(rng);
    }
 
    constexpr rng_t const && base() const && noexcept
    {
        return std::move(rng);
    }
 
    constexpr std::ranges::iterator_t<rng_t> begin()
    {
        return std::ranges::begin(rng);
    }
 
    constexpr auto begin() const
        requires std::ranges::range<rng_t const>
    {
        return std::ranges::begin(rng);
    }
 
    constexpr std::ranges::sentinel_t<rng_t> end()
    {
        return std::ranges::end(rng);
    }
 
    constexpr auto end() const
        requires std::ranges::range<rng_t const>
    {
        return std::ranges::end(rng);
    }
 
    constexpr bool empty()
        requires requires { std::ranges::empty(rng); }
    {
        return std::ranges::empty(rng);
    }
 
    constexpr bool empty() const
        requires requires { std::ranges::empty(rng); }
    {
        return std::ranges::empty(rng);
    }
 
    constexpr auto size()
        requires std::ranges::sized_range<rng_t>
    {
        return std::ranges::size(rng);
    }
 
    constexpr auto size() const
        requires std::ranges::sized_range<rng_t const>
    {
        return std::ranges::size(rng);
    }
 
    constexpr auto data()
        requires std::ranges::contiguous_range<rng_t>
    {
        return std::ranges::data(rng);
    }
 
    constexpr auto data() const
        requires std::ranges::contiguous_range<rng_t const>
    {
        return std::ranges::data(rng);
    }
};
 
class all_fn : public adaptor_base<all_fn>
{
private:
    friend adaptor_base<all_fn>;
 
    template <typename t>
    static constexpr bool decays_to_view = std::ranges::view<std::decay_t<t>>;
 
    template <typename t>
    static constexpr bool valid_for_ref_view = requires { std::ranges::ref_view(std::declval<t>()); };
 
    template <typename t>
    static constexpr bool valid_for_owning_view = requires { owning_view(std::declval<t>()); };
 
public:
    using adaptor_base<all_fn>::adaptor_base;
 
    template <std::ranges::range rng_t>
        requires decays_to_view<rng_t> || valid_for_ref_view<rng_t> || valid_for_owning_view<rng_t>
    static auto impl(rng_t && rng)
    {
        if constexpr (decays_to_view<rng_t>)
            return std::forward<rng_t>(rng);
        else if constexpr (valid_for_ref_view<rng_t>)
            return std::ranges::ref_view{std::forward<rng_t>(rng)};
        else
            return owning_view{std::forward<rng_t>(rng)};
    }
};
 
inline constexpr auto all = all_fn{};
 
template <std::ranges::range rng_t>
using all_t = decltype(all(std::declval<rng_t>()));
 
} // namespace seqan3::detail
#endif // __cpp_lib_ranges >= 202110L