interleave.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 <cmath>

#include <range/v3/view/chunk.hpp>

#include <seqan3/core/type_traits/pre.hpp>
#include <seqan3/core/type_traits/transformation_trait_or.hpp>
#include <seqan3/range/detail/random_access_iterator.hpp>
#include <seqan3/range/view/detail.hpp>
#include <seqan3/range/view/persist.hpp>
#include <seqan3/range/view/view_all.hpp>
#include <seqan3/std/concepts>
#include <seqan3/std/ranges>

namespace seqan3::detail
{

// ============================================================================
//  view_interleave
// ============================================================================

template <std::ranges::RandomAccessRange urng_t, std::ranges::RandomAccessRange inserted_rng_t>
    requires std::ranges::View<urng_t> && std::ranges::SizedRange<urng_t> &&
             std::ranges::View<inserted_rng_t> && std::ranges::SizedRange<inserted_rng_t> &&
             std::CommonReference<reference_t<urng_t>, reference_t<inserted_rng_t>>
class view_interleave : public std::ranges::view_interface<view_interleave<urng_t, inserted_rng_t>>
{
private:
    urng_t urange;
    size_t step_size{};
    inserted_rng_t inserted_range;

public:
    using reference         = ranges::common_reference_t<reference_t<urng_t>, reference_t<inserted_rng_t>>;
    using const_reference   = detail::transformation_trait_or_t<
                                ranges::common_reference<reference_t<urng_t const>, reference_t<inserted_rng_t const>>, void>;
    using value_type        = value_type_t<urng_t>;
    using size_type         = size_type_t<urng_t>;
    using difference_type   = difference_type_t<urng_t>;
    using iterator          = detail::random_access_iterator<view_interleave>;
    using const_iterator    = detail::random_access_iterator<view_interleave const>;

    constexpr view_interleave()                                        noexcept = default; 
    constexpr view_interleave(view_interleave const & rhs)             noexcept = default; 
    constexpr view_interleave(view_interleave && rhs)                  noexcept = default; 
    constexpr view_interleave & operator=(view_interleave const & rhs) noexcept = default; 
    constexpr view_interleave & operator=(view_interleave && rhs)      noexcept = default; 
    ~view_interleave()                                                 noexcept = default; 

    view_interleave(urng_t && _urange, size_t const _step_size, inserted_rng_t && _inserted_range) :
        urange{_urange}, step_size{_step_size}, inserted_range{_inserted_range}
    {}

    template <typename orng_t, typename oirng_t>
        requires std::Constructible<urng_t, decltype(view::all(std::declval<orng_t>()))> &&
                 std::Constructible<inserted_rng_t, decltype(view::persist(std::declval<oirng_t>()))>
    view_interleave(orng_t && _urange, size_t const _step_size, oirng_t && _inserted_range) :
        view_interleave{view::all(std::forward<orng_t>(_urange)), _step_size, view::persist(std::forward<oirng_t>(_inserted_range))}
    {}

    iterator begin() noexcept
    {
        return {*this, 0};
    }

    const_iterator begin() const noexcept
    {
        return {*this, 0};
    }

    const_iterator cbegin() const noexcept
    {
        return begin();
    }

    iterator end() noexcept
    {
        return {*this, size()};
    }

    const_iterator end() const noexcept
    {
        return {*this, size()};
    }

    const_iterator cend() const noexcept
    {
        return end();
    }

    size_type size()
    {
        return std::ranges::size(urange) +
               ((std::floor(std::ranges::size(urange) / step_size) -
                (std::ranges::size(urange) % step_size == 0 ? 1 : 0)) *
                std::ranges::size(inserted_range));
    }

    size_type size() const
    {
        return std::ranges::size(urange) +
               ((std::floor(std::ranges::size(urange) / step_size) -
                (std::ranges::size(urange) % step_size == 0 ? 1 : 0)) *
                std::ranges::size(inserted_range));
    }

    reference operator[](size_type const i)
    {
        size_t combined_size = step_size + std::ranges::size(inserted_range);
        assert(i < size());
        if (i % (combined_size) < step_size)
            return urange[i - (std::floor(i/(combined_size)) * std::ranges::size(inserted_range))];
        else
            return inserted_range[(i % (combined_size)) - step_size];
    }

    const_reference operator[](size_type const i) const
    {
        size_t combined_size = step_size + std::ranges::size(inserted_range);
        assert(i < size());
        if (i % (combined_size) < step_size)
            return urange[i - (std::floor(i/(combined_size)) * std::ranges::size(inserted_range))];
        else
            return inserted_range[(i % (combined_size)) - step_size];
    }
};

template <std::ranges::RandomAccessRange urng_t, std::ranges::RandomAccessRange inserted_rng_t>
    requires std::ranges::ViewableRange<urng_t> && std::ranges::SizedRange<urng_t> &&
             std::ranges::SizedRange<inserted_rng_t> &&
             std::CommonReference<reference_t<urng_t>, reference_t<inserted_rng_t>>
view_interleave(urng_t &&, size_t, inserted_rng_t &&)
    -> view_interleave<decltype(view::all(std::declval<urng_t>())), decltype(view::persist(std::declval<inserted_rng_t>()))>;

// ============================================================================
//  interleave_fn (adaptor definition)
// ============================================================================

struct interleave_fn
{
    template <std::ranges::ForwardRange inserted_rng_t, std::Integral size_type>
    constexpr auto operator()(size_type const size, inserted_rng_t && i) const noexcept
    {
        return detail::adaptor_from_functor{*this, size, std::forward<inserted_rng_t>(i)};
    }

    template <std::ranges::Range urng_t, std::ranges::Range inserted_rng_t, std::Integral size_type>
    constexpr auto operator()(urng_t && urange, size_type const size, inserted_rng_t && i) const noexcept
    {
        static_assert(std::ranges::ForwardRange<urng_t>,
            "The underlying range parameter in view::interleave must model std::ranges::ForwardRange.");
        static_assert(std::ranges::ViewableRange<urng_t>,
            "The underlying range parameter in view::interleave must model std::ranges::ViewableRange.");
        static_assert(std::ranges::ForwardRange<inserted_rng_t>,
            "The range to be inserted by view::interleave must model std::ranges::ForwardRange.");
        if constexpr (std::ranges::RandomAccessRange<urng_t> && std::ranges::SizedRange<urng_t> &&
                      std::ranges::RandomAccessRange<inserted_rng_t> && std::ranges::SizedRange<inserted_rng_t>)
        {
            return detail::view_interleave{std::forward<urng_t>(urange),
                                           static_cast<size_t>(size),
                                           std::forward<inserted_rng_t>(i)};
        }
        else
        {
            return ranges::view::chunk(std::forward<urng_t>(urange), static_cast<size_t>(size))
                 | std::view::join(std::forward<inserted_rng_t>(i));
        }
    }
};

} // namespace seqan3::detail

// ============================================================================
//  view::interleave (adaptor instance definition)
// ============================================================================

namespace seqan3::view
{

inline constexpr auto interleave = detail::interleave_fn{};


} // namespace seqan3::view