translate_single.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/alphabet/aminoacid/aa27.hpp>
#include <bio/alphabet/aminoacid/translation.hpp>
#include <bio/alphabet/nucleotide/dna5.hpp>
#include <bio/ranges/views/deep.hpp>
#include <bio/ranges/views/transform_by_pos.hpp>
 
// ============================================================================
//  translate_fn (adaptor definition for both views)
// ============================================================================
 
namespace bio::ranges::detail
{
 
struct translate_single_fn
{
    static constexpr alphabet::translation_frames default_frames = alphabet::translation_frames::FWD_FRAME_0;
 
    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(std::ranges::viewable_range<urng_t>,
                      "The range parameter to views::translate_single must be viewable.");
        static_assert(std::ranges::sized_range<urng_t>,
                      "The range parameter to views::translate_single must model std::ranges::sized_range.");
        static_assert(std::ranges::random_access_range<urng_t>,
                      "The range parameter to views::translate_single must model std::ranges::random_access_range.");
        static_assert(alphabet::nucleotide<std::ranges::range_reference_t<urng_t>>,
                      "The range parameter to views::translate_single must be over elements of "
                      "bio::alphabet::alphabet::nucleotide.");
 
        /* frames */
        if (size_t const num_frames = std::popcount(static_cast<uint8_t>(tf));
            num_frames > 1 ||
            static_cast<uint8_t>(tf) > static_cast<uint8_t>(alphabet::translation_frames::REV_FRAME_2))
        {
            throw std::invalid_argument{
              "Error: Invalid type of frame. Choose one out of FWD_FRAME_0, "
              "REV_FRAME_0, FWD_FRAME_1, REV_FRAME_1, FWD_FRAME_2 and "
              "REV_FRAME_2."};
        }
 
        /* size */
        size_t const old_size = std::ranges::size(urange);
        size_t const new_size = comp_new_size(old_size, tf);
 
        return detail::view_transform_by_pos{
          std::forward<urng_t>(urange),
          trans_fn{.old_size = old_size, .new_size = new_size, .tf = tf},
          new_size
        };
    }
 
    template <std::ranges::range urng_t>
    constexpr friend auto operator|(urng_t && urange, translate_single_fn const & me)
    {
        return me(std::forward<urng_t>(urange));
    }
 
private:
    static size_t comp_new_size(size_t const old_size, alphabet::translation_frames const tf)
    {
        switch (tf)
        {
            case alphabet::translation_frames::FWD_FRAME_0:
                [[fallthrough]];
            case alphabet::translation_frames::REV_FRAME_0:
                return old_size / 3;
            case alphabet::translation_frames::FWD_FRAME_1:
                [[fallthrough]];
            case alphabet::translation_frames::REV_FRAME_1:
                return (std::max<size_t>(old_size, 1) - 1) / 3;
            case alphabet::translation_frames::FWD_FRAME_2:
                [[fallthrough]];
            case alphabet::translation_frames::REV_FRAME_2:
                return (std::max<size_t>(old_size, 2) - 2) / 3;
            default:   /* GCOVR_EXCL_LINE */
                BIOCPP_UNREACHABLE
                break; /* GCOVR_EXCL_LINE */
        }
 
        BIOCPP_UNREACHABLE
    }
 
    struct trans_fn
    {
        size_t                       old_size{};
        size_t                       new_size{};
        alphabet::translation_frames tf{};
 
        auto operator()(auto && urange2, size_t const n) const
        {
            assert(n < new_size);
            switch (tf) //TODO create function ptr so we do not need to switch every time? → benchmark
            {
                case alphabet::translation_frames::FWD_FRAME_0:
                    return alphabet::translate_triplet(urange2[n * 3], urange2[n * 3 + 1], urange2[n * 3 + 2]);
                case alphabet::translation_frames::REV_FRAME_0:
                    return alphabet::translate_triplet(alphabet::complement(urange2[old_size - n * 3 - 1]),
                                                       alphabet::complement(urange2[old_size - n * 3 - 2]),
                                                       alphabet::complement(urange2[old_size - n * 3 - 3]));
                case alphabet::translation_frames::FWD_FRAME_1:
                    return alphabet::translate_triplet(urange2[n * 3 + 1], urange2[n * 3 + 2], urange2[n * 3 + 3]);
                case alphabet::translation_frames::REV_FRAME_1:
                    return alphabet::translate_triplet(alphabet::complement(urange2[old_size - n * 3 - 2]),
                                                       alphabet::complement(urange2[old_size - n * 3 - 3]),
                                                       alphabet::complement(urange2[old_size - n * 3 - 4]));
                case alphabet::translation_frames::FWD_FRAME_2:
                    return alphabet::translate_triplet(urange2[n * 3 + 2], urange2[n * 3 + 3], urange2[n * 3 + 4]);
                case alphabet::translation_frames::REV_FRAME_2:
                    return alphabet::translate_triplet(alphabet::complement(urange2[old_size - n * 3 - 3]),
                                                       alphabet::complement(urange2[old_size - n * 3 - 4]),
                                                       alphabet::complement(urange2[old_size - n * 3 - 5]));
                default:   /* GCOVR_EXCL_LINE */
                    BIOCPP_UNREACHABLE
                    break; /* GCOVR_EXCL_LINE */
            }
            BIOCPP_UNREACHABLE
        }
    };
};
 
} // namespace bio::ranges::detail
 
// ============================================================================
//  translate_single (adaptor object)
// ============================================================================
 
namespace bio::ranges::views
{
 
inline constexpr auto translate_single = deep{detail::translate_single_fn{}};
 
} // namespace bio::ranges::views