translate_join.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// 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/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <vector>
#include <stdexcept>
 
#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/views/translate.hpp>
#include <seqan3/std/concepts>
#include <seqan3/std/ranges>
 
namespace seqan3::detail
{
 
// ============================================================================
//  view_translate_join (range definition)
// ============================================================================
 
template <std::ranges::view urng_t>
class view_translate_join : public ranges::view_base
{
private:
    urng_t urange;
    translation_frames tf;
    small_vector<translation_frames, 6> selected_frames{};
 
protected:
    template <typename, typename>
    friend class detail::random_access_iterator_base;
 
    using reference         = view_translate_single<std::ranges::all_view<reference_t<urng_t>>>;
    using const_reference   = reference;
    using value_type        = reference;
    using size_type         = size_type_t<reference_t<urng_t>>;
    using difference_type   = difference_type_t<reference_t<urng_t>>;
    using iterator          = detail::random_access_iterator<view_translate_join>;
    using const_iterator    = detail::random_access_iterator<view_translate_join const>;
 
public:
 
    static_assert(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 cannot be a temporary of a non-view range.");
    static_assert(std::ranges::viewable_range<reference_t<urng_t>>,
        "The inner range of the range parameter to views::translate_join cannot be a temporary of a non-view range.");
    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<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<reference_t<urng_t>>,
        "The inner range of the range parameter to views::translate_join must model std::ranges::random_access_range.");
    static_assert(nucleotide_alphabet<reference_t<reference_t<urng_t>>>,
        "The range parameter to views::translate_join must be over a range over elements of seqan3::nucleotide_alphabet.");
 
    view_translate_join()                                                      noexcept = default; 
    constexpr view_translate_join(view_translate_join const & rhs)             noexcept = default; 
    constexpr view_translate_join(view_translate_join && rhs)                  noexcept = default; 
    constexpr view_translate_join & operator=(view_translate_join const & rhs) noexcept = default; 
    constexpr view_translate_join & operator=(view_translate_join && rhs)      noexcept = default; 
    ~view_translate_join()                                                     noexcept = default; 
 
    view_translate_join(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_as<remove_cvref_t<rng_t>, view_translate_join> &&
                 std::ranges::viewable_range<rng_t> &&
                 std::constructible_from<urng_t, ranges::ref_view<std::remove_reference_t<rng_t>>>
    view_translate_join(rng_t && _urange, translation_frames const _tf = translation_frames::SIX_FRAME)
     : view_translate_join{std::views::all(std::forward<rng_t>(_urange)), _tf}
    {}
 
    iterator begin() noexcept
    {
        return {*this, 0};
    }
 
    const_iterator begin() const noexcept
        requires const_iterable_range<urng_t>
    {
        return {*this, 0};
    }
 
    const_iterator cbegin() const noexcept
        requires const_iterable_range<urng_t>
    {
        return begin();
    }
 
    iterator end() noexcept
    {
        return {*this, size()};
    }
 
    const_iterator end() const noexcept
        requires const_iterable_range<urng_t>
    {
        return {*this, size()};
    }
 
    const_iterator cend() const noexcept
        requires const_iterable_range<urng_t>
    {
        return end();
    }
 
    size_type size() noexcept
    {
        return (size_type) seqan3::size(urange) * selected_frames.size();
    }
 
    size_type size() const noexcept
        requires const_iterable_range<urng_t>
    {
        return (size_type) seqan3::size(urange) * selected_frames.size();
    }
 
    reference operator[](size_type const n)
    {
        assert(n < size());
        size_type index_frame = n % selected_frames.size();
        size_type index_urange = (n - index_frame) / selected_frames.size();
        return urange[index_urange] | views::translate_single(selected_frames[index_frame]);
    }
 
    const_reference operator[](size_type const n) const
        requires const_iterable_range<urng_t>
    {
        assert(n < size());
        size_type index_frame = n % selected_frames.size();
        size_type index_urange = (n - index_frame) / selected_frames.size();
        return urange[index_urange] | views::translate_single(selected_frames[index_frame]);
    }
};
 
template <typename urng_t>
view_translate_join(urng_t &&, translation_frames const = translation_frames{}) -> view_translate_join<std::ranges::all_view<urng_t>>;
 
// ============================================================================
//  translate_fn (adaptor definition for both views)
// ============================================================================
 
struct translate_join_fn
{
    constexpr auto operator()(translation_frames const tf = translation_frames::SIX_FRAME) const
    {
        return detail::adaptor_from_functor{*this, tf};
    }
 
    template <std::ranges::range urng_t>
    constexpr auto operator()(urng_t && urange, translation_frames const tf = translation_frames::SIX_FRAME) const
    {
        static_assert(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 cannot be a temporary of a non-view range.");
        static_assert(std::ranges::viewable_range<reference_t<urng_t>>,
            "The inner range of the range parameter to views::translate_join cannot be a temporary of a non-view range.");
        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<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<reference_t<urng_t>>,
            "The inner range of the range parameter to views::translate_join must model std::ranges::random_access_range.");
        static_assert(nucleotide_alphabet<reference_t<reference_t<urng_t>>>,
            "The range parameter to views::translate_join must be over a range over elements of seqan3::nucleotide_alphabet.");
 
        return detail::view_translate_join{std::forward<urng_t>(urange), tf};
    }
 
    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));
    }
};
 
} // namespace seqan3::detail
 
// ============================================================================
//  translate (adaptor object)
// ============================================================================
 
namespace seqan3::views
{
 
inline constexpr auto translate_join = detail::translate_join_fn{};
 
} // namespace seqan3::views