to.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2022 deCODE Genetics
// 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/biocpp/biocpp-core/blob/main/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <algorithm>
#include <ranges>
 
#include <bio/ranges/views/detail.hpp>
 
namespace bio::ranges::detail
{
 
template <typename container_t>
struct to_fn
{
private:
    auto impl(std::ranges::range auto && rng, container_t & container) const
    {
        std::ranges::copy(rng, std::back_inserter(container));
    }
 
    auto impl(std::ranges::range auto && rng, container_t & container) const
        requires std::ranges::range<std::decay_t<decltype(*rng.begin())>>
    {
        auto adapter   = to_fn<typename container_t::value_type>{};
        auto inner_rng = rng | std::views::transform(adapter);
        std::ranges::copy(inner_rng, std::back_inserter(container));
    }
 
public:
    template <std::ranges::range rng_t, typename... args_t>
    constexpr auto operator()(rng_t && rng, args_t &&... args) const
    {
        auto r = 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(std::size_t{}); })
        {
            r.reserve(std::ranges::size(rng));
        }
 
        impl(std::forward<rng_t>(rng), r);
        return r;
    }
};
 
template <template <typename...> typename container_t>
struct to_template_template_fn
{
    template <std::ranges::range rng_t, typename... args_t>
    constexpr auto operator()(rng_t && rng, args_t &&... args) const
    {
        using value_t = std::decay_t<decltype(*rng.begin())>;
        auto adapter  = to_fn<container_t<value_t>>{};
        return adapter(std::forward<rng_t>(rng), std::forward<args_t>(args)...);
    }
};
 
} //namespace bio::ranges::detail
 
namespace bio::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::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 <typename...> typename container_t, std::ranges::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 bio::ranges