deep.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/std/ranges>
 
namespace seqan3::views
{
 
template <typename underlying_adaptor_t>
class deep : public detail::adaptor_base<deep<underlying_adaptor_t>, underlying_adaptor_t>
{
private:
    using base_type = detail::adaptor_base<deep<underlying_adaptor_t>, underlying_adaptor_t>;
 
    friend base_type;
 
public:
    constexpr deep()                         noexcept = default; 
    constexpr deep(deep const &)             noexcept = default; 
    constexpr deep(deep &&)                  noexcept = default; 
    constexpr deep & operator=(deep const &) noexcept = default; 
    constexpr deep & operator=(deep &&)      noexcept = default; 
    ~deep()                                  noexcept = default; 
 
    using base_type::base_type;
 
 
    using base_type::operator();
 
    template <std::ranges::input_range urng_t, typename underlying_adaptor_t_>
    static constexpr auto impl(urng_t && urange, underlying_adaptor_t_ && adap)
    {
        // this function recursively constructs a view (moves/forwards omitted for readability):
        // return range | std::views::transform([adap](auto && inner_range_depth1)
        // {
        //     return inner_range_depth1 | std::views::transform([adap](auto && inner_range_depth2)
        //     {
        //         // ...
        //         return inner_range_depth_n | std::views::transform([adap](auto && inner_most_range)
        //         {
        //             return inner_most_range | adap;
        //         });
        //         // ...
        //     });
        // });
 
        // Note: we avoid the (unqualified) pipe|-notation and use function notation here, to avoid problems with ADL.
        if constexpr (std::ranges::input_range<std::ranges::range_reference_t<urng_t>>)
        {
            auto transform = [adaptor = std::forward<underlying_adaptor_t_>(adap)] (auto && inner_range)
            {
                // recursively call impl until inner most range is reached.
                return impl(std::forward<decltype(inner_range)>(inner_range), std::forward<decltype(adaptor)>(adaptor));
            };
            return std::views::transform(std::forward<urng_t>(urange), std::move(transform));
        }
        else
        {
            // recursion anchor: this is the inner most range
            return std::forward<underlying_adaptor_t_>(adap)(std::forward<urng_t>(urange));
        }
    }
 
    template <typename first_arg_t, typename ...stored_arg_types>
        requires (!std::ranges::input_range<first_arg_t>)
    constexpr auto operator()(first_arg_t && first, stored_arg_types && ...args) const
    {
        // The adaptor currently wrapped is a proto-adaptor and this function has the arguments to "complete" it.
        // We extract the adaptor that is stored and invoke it with the given arguments.
        // This returns an adaptor closure object.
        auto adaptor_closure = std::get<0>(this->arguments)(std::forward<first_arg_t>(first),
                                                            std::forward<stored_arg_types>(args)...);
        // Now we wrap this closure object back into a views::deep to get the deep behaviour.
        return deep<decltype(adaptor_closure)>{std::move(adaptor_closure)};
    }
 
    constexpr auto operator()() const
    {
        // Proto-adaptors require arguments by definition, but some support defaulting those (e.g. views::translate).
        // This extracts the proto adaptor and invokes it without args which yields a different object, the closure
        // with default arguments.
        auto adaptor_closure = std::get<0>(this->arguments)();
        // Now we wrap this closure object back into a views::deep to get the deep behaviour.
        return deep<decltype(adaptor_closure)>{std::move(adaptor_closure)};
    }
 
    template <std::ranges::input_range urng_t, typename ...stored_arg_types>
        requires (sizeof...(stored_arg_types) > 0)
    constexpr auto operator()(urng_t && urange, stored_arg_types && ...args) const
    {
        auto adaptor_closure = std::get<0>(this->arguments)(std::forward<stored_arg_types>(args)...);
        deep<decltype(adaptor_closure)> deep_adaptor{std::move(adaptor_closure)};
        return deep_adaptor(std::forward<urng_t>(urange));
    }
};
 
template <typename underlying_adaptor_t>
deep(underlying_adaptor_t && inner) -> deep<underlying_adaptor_t>;
 
 
} // namespace seqan3::views