translate.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 <vector>
#include <stdexcept>

#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/aminoacid/aa27.hpp>
#include <seqan3/alphabet/aminoacid/translation.hpp>
#include <seqan3/core/add_enum_bitwise_operators.hpp>
#include <seqan3/core/type_traits/range.hpp>
#include <seqan3/range/container/small_string.hpp>
#include <seqan3/range/detail/random_access_iterator.hpp>
#include <seqan3/range/view/deep.hpp>
#include <seqan3/range/view/detail.hpp>
#include <seqan3/std/concepts>
#include <seqan3/std/ranges>
#include <seqan3/range/container/concept.hpp>

// ============================================================================
//  forwards
// ============================================================================

namespace seqan3::detail
{

template <std::ranges::View urng_t>
    requires std::ranges::SizedRange<urng_t> &&
             std::ranges::RandomAccessRange<urng_t> &&
             NucleotideAlphabet<reference_t<urng_t>>
class view_translate;

template <std::ranges::View urng_t>
    requires std::ranges::SizedRange<urng_t> &&
             std::ranges::RandomAccessRange<urng_t> &&
             NucleotideAlphabet<reference_t<urng_t>>
class view_translate_single;

} // namespace seqan3::detail

// ============================================================================
//  translation_frames
// ============================================================================

namespace seqan3
{

enum class translation_frames : uint8_t
{
    FWD_FRAME_0 = 1,                                    
    FWD_FRAME_1 = 1 << 1,                               
    FWD_FRAME_2 = 1 << 2,                               
    REV_FRAME_0 = 1 << 3,                               
    REV_FRAME_1 = 1 << 4,                               
    REV_FRAME_2 = 1 << 5,                               
    FWD_REV_0 = FWD_FRAME_0 | REV_FRAME_0,              
    FWD_REV_1 = FWD_FRAME_1 | REV_FRAME_1,              
    FWD_REV_2 = FWD_FRAME_2 | REV_FRAME_2,              
    FWD = FWD_FRAME_0 | FWD_FRAME_1 | FWD_FRAME_2,      
    REV = REV_FRAME_0 | REV_FRAME_1 | REV_FRAME_2,      
    SIX_FRAME = FWD | REV                               
};

template<>
constexpr bool add_enum_bitwise_operators<translation_frames> = true;

}

namespace seqan3::detail
{

// ============================================================================
//  translate_fn (adaptor definition for both views)
// ============================================================================

template <bool single>
struct translate_fn
{
    static constexpr translation_frames default_frames = single ?
                                                         translation_frames::FWD_FRAME_0 :
                                                         translation_frames::SIX_FRAME;

    constexpr auto operator()(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, translation_frames const tf = default_frames) const
    {
        static_assert(std::ranges::ViewableRange<urng_t>,
            "The range parameter to view::translate[_single] cannot be a temporary of a non-view range.");
        static_assert(std::ranges::SizedRange<urng_t>,
            "The range parameter to view::translate[_single] must model std::ranges::SizedRange.");
        static_assert(std::ranges::RandomAccessRange<urng_t>,
            "The range parameter to view::translate[_single] must model std::ranges::RandomAccessRange.");
        static_assert(NucleotideAlphabet<reference_t<urng_t>>,
            "The range parameter to view::translate[_single] must be over elements of seqan3::NucleotideAlphabet.");

        if constexpr (single)
            return detail::view_translate_single{std::forward<urng_t>(urange), tf};
        else
            return detail::view_translate{std::forward<urng_t>(urange), tf};
    }

    template <std::ranges::Range urng_t>
    constexpr friend auto operator|(urng_t && urange, translate_fn const & me)
    {
        return me(std::forward<urng_t>(urange));
    }
};

// ============================================================================
//  view_translate_single (range definition)
// ============================================================================

template <std::ranges::View urng_t>
    requires std::ranges::SizedRange<urng_t> &&
             std::ranges::RandomAccessRange<urng_t> &&
             NucleotideAlphabet<reference_t<urng_t>>
class view_translate_single : public ranges::view_base
{
private:
    urng_t urange;
    translation_frames tf;
    static constexpr small_string multiple_frame_error{"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."};
public:
    using reference         = aa27;
    using const_reference   = aa27;
    using value_type        = aa27;
    using size_type         = size_type_t<urng_t>;
    using difference_type   = difference_type_t<urng_t>;
    using iterator          = detail::random_access_iterator<view_translate_single>;
    using const_iterator    = detail::random_access_iterator<view_translate_single const>;

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


    view_translate_single(urng_t _urange, translation_frames const _tf = translation_frames::FWD_FRAME_0)
        : urange{std::move(_urange)}, tf{_tf}
    {
        if (__builtin_popcount(static_cast<uint8_t>(_tf)) > 1)
        {
            throw std::invalid_argument(multiple_frame_error.c_str());
        }
    }

    template <typename rng_t>
     requires !std::Same<remove_cvref_t<rng_t>, view_translate_single> &&
              std::ranges::ViewableRange<rng_t> &&
              std::Constructible<urng_t, ranges::ref_view<std::remove_reference_t<rng_t>>>
    view_translate_single(rng_t && _urange, translation_frames const _tf = translation_frames::FWD_FRAME_0)
     : view_translate_single{std::view::all(std::forward<rng_t>(_urange)), _tf}
    {}

    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()
    {
        switch (tf)
        {
            case translation_frames::FWD_FRAME_0:
                [[fallthrough]];
            case translation_frames::REV_FRAME_0:
                return seqan3::size(urange) / 3;
                break;
            case translation_frames::FWD_FRAME_1:
                [[fallthrough]];
            case translation_frames::REV_FRAME_1:
                return (seqan3::size(urange) - 1) / 3;
                break;
            case translation_frames::FWD_FRAME_2:
                [[fallthrough]];
            case translation_frames::REV_FRAME_2:
                return (seqan3::size(urange) - 2) / 3;
                break;
            default:
                throw std::invalid_argument(multiple_frame_error.c_str());
                break;
        }
    }

    size_type size() const
    {
        switch (tf)
        {
            case translation_frames::FWD_FRAME_0:
                [[fallthrough]];
            case translation_frames::REV_FRAME_0:
                return seqan3::size(urange) / 3;
                break;
            case translation_frames::FWD_FRAME_1:
                [[fallthrough]];
            case translation_frames::REV_FRAME_1:
                return (seqan3::size(urange) - 1) / 3;
                break;
            case translation_frames::FWD_FRAME_2:
                [[fallthrough]];
            case translation_frames::REV_FRAME_2:
                return (seqan3::size(urange) - 2) / 3;
                break;
            default:
                throw std::invalid_argument(multiple_frame_error.c_str());
                break;
        }
    }

    reference operator[](size_type const n)
    {
        assert(n < size());
        switch (tf)
        {
         case translation_frames::FWD_FRAME_0:
             return translate_triplet((urange)[n * 3], (urange)[n * 3 + 1], (urange)[n * 3 + 2]);
             break;
         case translation_frames::REV_FRAME_0:
             return translate_triplet(complement((urange)[(urange).size() - n * 3 - 1]), complement((urange)[(urange).size() - n * 3 - 2]), complement((urange)[(urange).size() - n * 3 - 3]));
             break;
         case translation_frames::FWD_FRAME_1:
             return translate_triplet((urange)[n * 3 + 1], (urange)[n * 3 + 2], (urange)[n * 3 + 3]);
             break;
         case translation_frames::REV_FRAME_1:
             return translate_triplet(complement((urange)[(urange).size() - n * 3 - 2]), complement((urange)[(urange).size() - n * 3 - 3]), complement((urange)[(urange).size() - n * 3 - 4]));
             break;
         case translation_frames::FWD_FRAME_2:
             return translate_triplet((urange)[n * 3 + 2], (urange)[n * 3 + 3], (urange)[n * 3 + 4]);
             break;
         case translation_frames::REV_FRAME_2:
             return translate_triplet(complement((urange)[(urange).size() - n * 3 - 3]), complement((urange)[(urange).size() - n * 3 - 4]), complement((urange)[(urange).size() - n * 3 - 5]));
             break;
         default:
             throw std::invalid_argument(multiple_frame_error.c_str());
             break;
        }
    }

    const_reference operator[](size_type const n) const
    {
        assert(n < size());
        switch (tf)
        {
            case translation_frames::FWD_FRAME_0:
                return translate_triplet((urange)[n * 3], (urange)[n * 3 + 1], (urange)[n * 3 + 2]);
                break;
            case translation_frames::REV_FRAME_0:
                return translate_triplet(complement((urange)[(urange).size() - n * 3 - 1]), complement((urange)[(urange).size() - n * 3 - 2]), complement((urange)[(urange).size() - n * 3 - 3]));
                break;
            case translation_frames::FWD_FRAME_1:
                return translate_triplet((urange)[n * 3 + 1], (urange)[n * 3 + 2], (urange)[n * 3 + 3]);
                break;
            case translation_frames::REV_FRAME_1:
                return translate_triplet(complement((urange)[(urange).size() - n * 3 - 2]), complement((urange)[(urange).size() - n * 3 - 3]), complement((urange)[(urange).size() - n * 3 - 4]));
                break;
            case translation_frames::FWD_FRAME_2:
                return translate_triplet((urange)[n * 3 + 2], (urange)[n * 3 + 3], (urange)[n * 3 + 4]);
                break;
            case translation_frames::REV_FRAME_2:
                return translate_triplet(complement((urange)[(urange).size() - n * 3 - 3]), complement((urange)[(urange).size() - n * 3 - 4]), complement((urange)[(urange).size() - n * 3 - 5]));
                break;
            default:
                throw std::invalid_argument(multiple_frame_error.c_str());
                break;
        }
    }
};

template <typename urng_t>
view_translate_single(urng_t &&, translation_frames const) -> view_translate_single<std::ranges::all_view<urng_t>>;


template <typename urng_t>
view_translate_single(urng_t &&) -> view_translate_single<std::ranges::all_view<urng_t>>;

} // namespace seqan3::detail

// ============================================================================
//  translate_single (adaptor object)
// ============================================================================

namespace seqan3::view
{

inline constexpr auto translate_single = deep{detail::translate_fn<true>{}};

} // seqan3::view

// ============================================================================
//  view_translate (range definition)
// ============================================================================

namespace seqan3::detail
{

template <std::ranges::View urng_t>
    requires std::ranges::SizedRange<urng_t> &&
             std::ranges::RandomAccessRange<urng_t> &&
             NucleotideAlphabet<reference_t<urng_t>>
class view_translate : public ranges::view_base
{
private:
    urng_t urange;
    translation_frames tf;
    small_vector<translation_frames, 6> selected_frames{};

public:
    using reference         = view_translate_single<urng_t>;
    using const_reference   = reference;
    using value_type        = reference;
    using size_type         = size_type_t<urng_t>;
    using difference_type   = difference_type_t<urng_t>;
    using iterator          = detail::random_access_iterator<view_translate>;
    using const_iterator    = detail::random_access_iterator<view_translate const>;

protected:
    // unfortunately we cannot specialise the variable template so we have to add an auxiliary here
    template <typename t>
        requires (dimension_v<t> == dimension_v<value_type> + 1) &&
                 std::is_same_v<remove_cvref_t<innermost_value_type_t<value_type>>,
                                remove_cvref_t<innermost_value_type_t<t>>>
    static constexpr bool is_compatible_this_aux = true;

public:

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

    view_translate(urng_t _urange, translation_frames const _tf = translation_frames::SIX_FRAME)
        : urange{std::move(_urange)}, tf{_tf}
    {
        if ((_tf & translation_frames::FWD_FRAME_0) == translation_frames::FWD_FRAME_0)
            selected_frames.push_back(translation_frames::FWD_FRAME_0);
        if ((_tf & translation_frames::FWD_FRAME_1) == translation_frames::FWD_FRAME_1)
            selected_frames.push_back(translation_frames::FWD_FRAME_1);
        if ((_tf & translation_frames::FWD_FRAME_2) == translation_frames::FWD_FRAME_2)
            selected_frames.push_back(translation_frames::FWD_FRAME_2);
        if ((_tf & translation_frames::REV_FRAME_0) == translation_frames::REV_FRAME_0)
            selected_frames.push_back(translation_frames::REV_FRAME_0);
        if ((_tf & translation_frames::REV_FRAME_1) == translation_frames::REV_FRAME_1)
            selected_frames.push_back(translation_frames::REV_FRAME_1);
        if ((_tf & translation_frames::REV_FRAME_2) == translation_frames::REV_FRAME_2)
            selected_frames.push_back(translation_frames::REV_FRAME_2);
    }

    template <typename rng_t>
        requires !std::Same<remove_cvref_t<rng_t>, view_translate> &&
                 std::ranges::ViewableRange<rng_t> &&
                 std::Constructible<urng_t, ranges::ref_view<std::remove_reference_t<rng_t>>>
    view_translate(rng_t && _urange, translation_frames const _tf = translation_frames::SIX_FRAME)
     : view_translate{std::view::all(std::forward<rng_t>(_urange)), _tf}
    {}

    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() noexcept
    {
        return (size_type) selected_frames.size();
    }

    size_type size() const noexcept
    {
        return (size_type) selected_frames.size();
    }

    reference operator[](size_type const n)
    {
        assert(n < size());
        return urange | view::translate_single(selected_frames[n]);
    }

    const_reference operator[](size_type const n) const
    {
        assert(n < size());
        return urange | view::translate_single(selected_frames[n]);
    }
};

template <typename urng_t>
    requires std::ranges::SizedRange<urng_t> &&
             std::ranges::RandomAccessRange<urng_t> &&
             NucleotideAlphabet<reference_t<urng_t>>
view_translate(urng_t &&, translation_frames const = translation_frames{}) -> view_translate<std::ranges::all_view<urng_t>>;

} // namespace seqan3::detail

// ============================================================================
//  translate (adaptor object)
// ============================================================================

namespace seqan3::view
{

inline constexpr auto translate = deep{detail::translate_fn<false>{}};

} // namespace seqan3::view