deep.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, 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/view/detail.hpp>
#include <seqan3/std/ranges>

namespace seqan3::view
{

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:
    using base_type::base_type;


    using base_type::operator();

    template <std::ranges::InputRange urng_t, typename underlying_adaptor_t_>
    static constexpr auto impl(urng_t && urange, underlying_adaptor_t_ && adap)
    {
        return std::forward<urng_t>(urange) | std::forward<underlying_adaptor_t_>(adap);
    }

    template <std::ranges::InputRange urng_t>
        requires std::ranges::InputRange<reference_t<urng_t>>
    constexpr auto operator()(urng_t && urange) const &
    {
        return std::forward<urng_t>(urange) | std::view::transform([me = *this] (auto && e)
        {
            return std::forward<decltype(e)>(e) | me;
        });
    }

    template <std::ranges::InputRange urng_t>
        requires std::ranges::InputRange<reference_t<urng_t>>
    constexpr auto operator()(urng_t && urange) &&
    {
        return std::forward<urng_t>(urange) | std::view::transform([me = std::move(*this)] (auto && e)
        {
            return std::forward<decltype(e)>(e) | me;
        });
    }

    template <typename first_arg_t, typename ... stored_arg_types>
        requires !std::ranges::InputRange<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 view::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. view::translate).
        // This extracts the proto adaptor and invokes it without args which yields a different object, the closure
        // with defaulted arguments.
        auto adaptor_closure = std::get<0>(this->arguments)();
        // Now we wrap this closure object back into a view::deep to get the deep behaviour.
        return deep<decltype(adaptor_closure)>{std::move(adaptor_closure)};
    }

    template <std::ranges::InputRange 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)...);
        return std::forward<urng_t>(urange) | std::move(adaptor_closure);
    }
};

template <typename underlying_adaptor_t>
deep(underlying_adaptor_t && inner) -> deep<underlying_adaptor_t>;


} // namespace seqan3::view