deep.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2022 deCODE Genetics
// 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/biocpp/biocpp-core/blob/main/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <ranges>
 
#include <bio/ranges/views/detail.hpp>
 
namespace bio::ranges::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)
    {
        return std::forward<urng_t>(urange) | std::forward<underlying_adaptor_t_>(adap);
    }
 
    template <std::ranges::input_range urng_t>
        requires std::ranges::input_range<std::ranges::range_reference_t<urng_t>>
    constexpr auto operator()(urng_t && urange) const &
    {
        return std::forward<urng_t>(urange) |
               std::views::transform([me = *this](auto && e) { return std::forward<decltype(e)>(e) | me; });
    }
 
    template <std::ranges::input_range urng_t>
        requires std::ranges::input_range<std::ranges::range_reference_t<urng_t>>
    constexpr auto operator()(urng_t && urange) &&
    {
        return std::forward<urng_t>(urange) |
               std::views::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::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 defaulted 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)...);
        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 bio::ranges::views