to.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 <algorithm>
#include <ranges>
 
#include <seqan3/core/range/detail/adaptor_from_functor.hpp>
#include <seqan3/utility/concept.hpp>
 
namespace seqan3::detail
{
 
template <typename container_t>
    requires (!std::ranges::view<container_t>)
struct to_fn
{
private:
    template <std::ranges::input_range rng_t>
        requires std::convertible_to<std::ranges::range_reference_t<rng_t>, std::ranges::range_value_t<container_t>>
    auto impl(rng_t && rng, container_t & container) const
    {
        std::ranges::copy(rng, std::back_inserter(container));
    }
 
    template <std::ranges::input_range rng_t>
    auto impl(rng_t && rng, container_t & container) const
        requires std::ranges::input_range<std::ranges::range_value_t<rng_t>>
    {
        auto adaptor = to_fn<std::ranges::range_value_t<container_t>>{};
        auto inner_rng = rng | std::views::transform(adaptor);
        std::ranges::copy(inner_rng, std::back_inserter(container));
    }
 
public:
    template <std::ranges::input_range rng_t, typename... args_t>
    constexpr auto operator()(rng_t && rng, args_t &&... args) const
    {
        auto new_container = container_t(std::forward<args_t>(args)...);
 
        // reserve memory if functionality is available
        if constexpr (std::ranges::sized_range<rng_t> && requires (container_t c) { c.reserve(size_t{}); })
            new_container.reserve(std::ranges::size(rng));
 
        impl(std::forward<rng_t>(rng), new_container);
        return new_container;
    }
};
 
template <template <typename> typename container_t>
struct to_template_template_fn
{
    template <std::ranges::input_range rng_t, typename... args_t>
    constexpr auto operator()(rng_t && rng, args_t &&... args) const
    {
        auto adaptor = to_fn<container_t<std::ranges::range_value_t<rng_t>>>{};
        return adaptor(std::forward<rng_t>(rng), std::forward<args_t>(args)...);
    }
};
 
} // namespace seqan3::detail
 
namespace seqan3::ranges
{
 
template <typename container_t, typename... args_t>
constexpr auto to(args_t &&... args)
{
    return detail::adaptor_from_functor{detail::to_fn<container_t>{}, std::forward<args_t>(args)...};
}
 
template <template <typename...> typename container_t, typename... args_t>
constexpr auto to(args_t &&... args)
{
    return detail::adaptor_from_functor{detail::to_template_template_fn<container_t>{}, std::forward<args_t>(args)...};
}
 
template <typename container_t, std::ranges::input_range rng_t, typename... args_t>
constexpr auto to(rng_t && rng, args_t &&... args)
{
    return detail::adaptor_from_functor{detail::to_fn<container_t>{},
                                        std::forward<args_t>(args)...}(std::forward<rng_t>(rng));
}
 
template <template <class...> typename container_t, std::ranges::input_range rng_t, typename... args_t>
constexpr auto to(rng_t && rng, args_t &&... args)
{
    return detail::adaptor_from_functor{detail::to_template_template_fn<container_t>{},
                                        std::forward<args_t>(args)...}(std::forward<rng_t>(rng));
}
 
} // namespace seqan3::ranges