interleave.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 <cmath>
#include <concepts>
#include <ranges>
 
#include <bio/ranges/views/transform_by_pos.hpp>
 
namespace bio::ranges::detail
{
 
// ============================================================================
//  interleave_fn (adaptor definition)
// ============================================================================
 
struct interleave_fn
{
private:
    template <typename irange_t>
    struct func
    {
        std::views::all_t<irange_t> irange;
        size_t                      step_size = 0;
 
        template <typename urng_t>
        constexpr auto operator()(urng_t && urange, size_t const i) const
          -> std::common_reference_t<std::ranges::range_reference_t<urng_t>,
                                     std::ranges::range_reference_t<decltype(std::as_const(irange))>>
        {
            size_t const div  = i / (step_size + std::ranges::size(irange));
            size_t const rest = i % (step_size + std::ranges::size(irange));
            return (rest < step_size) ? urange[i - div * std::ranges::size(irange)] : irange[rest - step_size];
        }
    };
 
public:
    template <std::ranges::forward_range inserted_rng_t>
    constexpr auto operator()(size_t const size, inserted_rng_t && i) const noexcept
    {
        return detail::adaptor_from_functor{*this, size, std::views::all(std::forward<inserted_rng_t>(i))};
    }
 
    template <std::ranges::range urng_t, std::ranges::range inserted_rng_t>
    constexpr auto operator()(urng_t && urange, size_t const step_size, inserted_rng_t && irange) const noexcept
    {
        static_assert(std::ranges::random_access_range<urng_t>,
                      "The underlying range parameter in views::interleave must model "
                      "std::ranges::random_access_range.");
        static_assert(std::ranges::viewable_range<urng_t>,
                      "The underlying range parameter in views::interleave must model std::ranges::viewable_range.");
        static_assert(std::ranges::sized_range<urng_t>,
                      "The underlying range parameter in views::interleave must model std::ranges::sized_range.");
 
        static_assert(std::ranges::random_access_range<inserted_rng_t>,
                      "The range to be inserted by views::interleave must model std::ranges::forward_range.");
        static_assert(std::ranges::sized_range<inserted_rng_t>,
                      "The range to be inserted by views::interleave must model std::ranges::sized_range.");
 
        static_assert(std::common_reference_with<std::ranges::range_reference_t<urng_t>,
                                                 std::ranges::range_reference_t<inserted_rng_t const>>,
                      "The underlying range and the CONST inserted range must have reference types that have a "
                      "common_reference type.");
 
        size_t const size =
          std::ranges::size(urange) +
          (((std::ranges::size(urange) / step_size) - (std::ranges::size(urange) % step_size == 0 ? 1 : 0)) *
           std::ranges::size(irange));
 
        func<std::views::all_t<inserted_rng_t>> fn{.irange    = std::views::all(std::forward<inserted_rng_t>(irange)),
                                                   .step_size = step_size};
 
        return view_transform_by_pos{std::forward<urng_t>(urange), std::move(fn), size};
    }
};
 
} // namespace bio::ranges::detail
 
// ============================================================================
//  views::interleave (adaptor instance definition)
// ============================================================================
 
namespace bio::ranges::views
{
 
inline constexpr auto interleave = detail::interleave_fn{};
 
 
} // namespace bio::ranges::views