translate_join.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 <concepts>
#include <ranges>
#include <stdexcept>
#include <vector>
 
#include <bio/ranges/container/small_string.hpp>
#include <bio/ranges/detail/random_access_iterator.hpp>
#include <bio/ranges/type_traits.hpp>
#include <bio/ranges/views/translate_single.hpp>
 
// ============================================================================
//  translate_fn (adaptor definition )
// ============================================================================
 
namespace bio::ranges::detail
{
 
struct translate_join_fn
{
    static constexpr alphabet::translation_frames default_frames = alphabet::translation_frames::SIX_FRAME;
 
    constexpr auto operator()(alphabet::translation_frames const tf = default_frames) const
    {
        return detail::adaptor_from_functor{*this, tf};
    }
 
    template <std::ranges::range urng_t>
    constexpr auto operator()(urng_t && urange, alphabet::translation_frames const tf = default_frames) const
    {
        static_assert(range_dimension_v<urng_t> == 2,
                      "This adaptor only handles range-of-range (two dimensions) as input.");
        static_assert(std::ranges::viewable_range<urng_t>,
                      "The range parameter to views::translate_join must be viewable.");
        static_assert(std::ranges::viewable_range<std::ranges::range_reference_t<urng_t>>,
                      "The inner range of the range parameter to views::translate_join must be viewable.");
        static_assert(std::ranges::sized_range<urng_t>,
                      "The range parameter to views::translate_join must model std::ranges::sized_range.");
        static_assert(std::ranges::sized_range<std::ranges::range_reference_t<urng_t>>,
                      "The inner range of the range parameter to views::translate_join must model "
                      "std::ranges::sized_range.");
        static_assert(std::ranges::random_access_range<urng_t>,
                      "The range parameter to views::translate_join must model std::ranges::random_access_range.");
        static_assert(std::ranges::random_access_range<std::ranges::range_reference_t<urng_t>>,
                      "The inner range of the range parameter to views::translate_join must model "
                      "std::ranges::random_access_range.");
        static_assert(alphabet::nucleotide<std::ranges::range_reference_t<std::ranges::range_reference_t<urng_t>>>,
                      "The range parameter to views::translate_join must be over a range over elements of "
                      "bio::alphabet::nucleotide.");
 
        /* frames */
        small_vector<alphabet::translation_frames, 6> selected_frames{};
        if ((tf & alphabet::translation_frames::FWD_FRAME_0) == alphabet::translation_frames::FWD_FRAME_0)
            selected_frames.push_back(alphabet::translation_frames::FWD_FRAME_0);
        if ((tf & alphabet::translation_frames::FWD_FRAME_1) == alphabet::translation_frames::FWD_FRAME_1)
            selected_frames.push_back(alphabet::translation_frames::FWD_FRAME_1);
        if ((tf & alphabet::translation_frames::FWD_FRAME_2) == alphabet::translation_frames::FWD_FRAME_2)
            selected_frames.push_back(alphabet::translation_frames::FWD_FRAME_2);
        if ((tf & alphabet::translation_frames::REV_FRAME_0) == alphabet::translation_frames::REV_FRAME_0)
            selected_frames.push_back(alphabet::translation_frames::REV_FRAME_0);
        if ((tf & alphabet::translation_frames::REV_FRAME_1) == alphabet::translation_frames::REV_FRAME_1)
            selected_frames.push_back(alphabet::translation_frames::REV_FRAME_1);
        if ((tf & alphabet::translation_frames::REV_FRAME_2) == alphabet::translation_frames::REV_FRAME_2)
            selected_frames.push_back(alphabet::translation_frames::REV_FRAME_2);
 
        size_t size = std::ranges::size(urange) * selected_frames.size();
        return detail::view_transform_by_pos{
          std::forward<urng_t>(urange),
          trans_fn{.size = size, .selected_frames = selected_frames},
          size
        };
    }
 
    template <std::ranges::range urng_t>
    constexpr friend auto operator|(urng_t && urange, translate_join_fn const & me)
    {
        return me(std::forward<urng_t>(urange));
    }
 
private:
    struct trans_fn
    {
        size_t                                        size{};
        small_vector<alphabet::translation_frames, 6> selected_frames{};
 
        auto operator()(auto && urange, size_t const n) const
        {
            assert(n < size);
            size_t index_frame  = n % selected_frames.size();
            size_t index_urange = (n - index_frame) / selected_frames.size();
            return urange[index_urange] | views::translate_single(selected_frames[index_frame]);
        }
    };
};
 
} // namespace bio::ranges::detail
 
// ============================================================================
//  translate (adaptor object)
// ============================================================================
 
namespace bio::ranges::views
{
 
inline constexpr auto translate_join = detail::translate_join_fn{};
 
} // namespace bio::ranges::views