affine_cell_proxy.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2021, 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 <seqan3/std/concepts>
#include <tuple>
#include <type_traits>
 
#include <seqan3/alignment/matrix/detail/trace_directions.hpp>
#include <seqan3/core/detail/empty_type.hpp>
#include <seqan3/utility/concept/exposition_only/core_language.hpp>
#include <seqan3/utility/simd/concept.hpp>
#include <seqan3/utility/tuple/concept.hpp>
 
namespace seqan3::detail
{
 
template <typename t>
SEQAN3_CONCEPT arithmetic_or_simd = arithmetic<t> || simd_concept<t>;
 
template <typename t>
SEQAN3_CONCEPT tracedirections_or_simd = std::same_as<std::remove_cvref_t<t>, trace_directions> || simd_concept<t>;
 
template <typename t>
SEQAN3_CONCEPT affine_score_cell = tuple_like<t> &&
                                   std::tuple_size_v<t> == 3 &&
                                   arithmetic_or_simd<std::remove_reference_t<std::tuple_element_t<0, t>>> &&
                                   arithmetic_or_simd<std::remove_reference_t<std::tuple_element_t<1, t>>> &&
                                   arithmetic_or_simd<std::remove_reference_t<std::tuple_element_t<2, t>>>;
 
template <typename t>
SEQAN3_CONCEPT affine_trace_cell = tuple_like<t> &&
                                   std::tuple_size_v<t> == 3 &&
                                   tracedirections_or_simd<std::remove_reference_t<std::tuple_element_t<0, t>>> &&
                                   tracedirections_or_simd<std::remove_reference_t<std::tuple_element_t<1, t>>> &&
                                   tracedirections_or_simd<std::remove_reference_t<std::tuple_element_t<2, t>>>;
 
template <typename t>
SEQAN3_CONCEPT affine_score_and_trace_cell = tuple_like<t> &&
                                             std::tuple_size_v<t> == 2 &&
                                             affine_score_cell<std::tuple_element_t<0, t>> &&
                                             affine_trace_cell<std::tuple_element_t<1, t>>;
 
template <typename tuple_t>
    requires (affine_score_cell<tuple_t> || affine_score_and_trace_cell<tuple_t>)
class affine_cell_proxy : public tuple_t
{
private:
    using score_cell_type = std::conditional_t<affine_score_cell<tuple_t>, tuple_t, std::tuple_element_t<0, tuple_t>>;
    using trace_cell_type = std::conditional_t<affine_score_and_trace_cell<tuple_t>,
                                               std::tuple_element_t<1, tuple_t>,
                                               empty_type>;
 
public:
    affine_cell_proxy() = default; 
    affine_cell_proxy(affine_cell_proxy const &) = default; 
    affine_cell_proxy(affine_cell_proxy &&) = default; 
    affine_cell_proxy & operator=(affine_cell_proxy const &) = default; 
    affine_cell_proxy & operator=(affine_cell_proxy &&) = default; 
    ~affine_cell_proxy() = default; 
 
    // Inherit the base class's constructor to enable element-wise initialisation (direct and converting constructor).
    using tuple_t::tuple_t;
 
    template <typename other_tuple_t>
        requires std::constructible_from<tuple_t, other_tuple_t &&>
    explicit affine_cell_proxy(other_tuple_t && other) :
        tuple_t{std::forward<other_tuple_t>(other)}
    {}
 
    template <typename other_tuple_t>
        requires std::constructible_from<tuple_t, other_tuple_t const &>
    explicit affine_cell_proxy(affine_cell_proxy<other_tuple_t> const & other) :
        tuple_t{static_cast<other_tuple_t const &>(other)}
    {}
 
    template <typename other_tuple_t>
        requires std::constructible_from<tuple_t, other_tuple_t>
    explicit affine_cell_proxy(affine_cell_proxy<other_tuple_t> && other) :
        tuple_t{static_cast<other_tuple_t &&>(std::move(other))}
    {}
 
    template <typename other_tuple_t>
        requires std::assignable_from<tuple_t &, other_tuple_t &&>
    affine_cell_proxy & operator=(other_tuple_t && other)
    {
        as_base() = std::forward<other_tuple_t>(other);
        return *this;
    }
 
    template <typename other_tuple_t>
        requires std::assignable_from<tuple_t &, other_tuple_t const &>
    affine_cell_proxy & operator=(affine_cell_proxy<other_tuple_t> const & other)
    {
        as_base() = static_cast<other_tuple_t const &>(other);
        return *this;
    }
 
    template <typename other_tuple_t>
        requires std::assignable_from<tuple_t &, other_tuple_t>
    affine_cell_proxy & operator=(affine_cell_proxy<other_tuple_t> && other)
    {
        as_base() = static_cast<other_tuple_t &&>(std::move(other));
        return *this;
    }
 
    decltype(auto) best_score() & noexcept { return get_score_impl<0>(*this); }
    decltype(auto) best_score() const & noexcept { return get_score_impl<0>(*this); }
    decltype(auto) best_score() && noexcept { return get_score_impl<0>(std::move(*this)); }
    decltype(auto) best_score() const && noexcept
    {
#if SEQAN3_WORKAROUND_GCC_94967
        // A simple std::move(...) does not work, because it would mess up tuple_element types like `int const &`
        using return_t = std::tuple_element_t<0, score_cell_type>;
        return static_cast<return_t const &&>(get_score_impl<0>(std::move(*this)));
#else // ^^^ workaround / no workaround vvv
        return get_score_impl<0>(std::move(*this));
#endif // SEQAN3_WORKAROUND_GCC_94967
    }
 
    decltype(auto) horizontal_score() & noexcept { return get_score_impl<1>(*this); }
    decltype(auto) horizontal_score() const & noexcept { return get_score_impl<1>(*this); }
    decltype(auto) horizontal_score() && noexcept { return get_score_impl<1>(std::move(*this)); }
    decltype(auto) horizontal_score() const && noexcept
    {
#if SEQAN3_WORKAROUND_GCC_94967
        // A simple std::move(...) does not work, because it would mess up tuple_element types like `int const &`
        using return_t = std::tuple_element_t<1, score_cell_type>;
        return static_cast<return_t const &&>(get_score_impl<1>(std::move(*this)));
#else // ^^^ workaround / no workaround vvv
        return get_score_impl<1>(std::move(*this));
#endif // SEQAN3_WORKAROUND_GCC_94967
    }
 
    decltype(auto) vertical_score() & noexcept { return get_score_impl<2>(*this); }
    decltype(auto) vertical_score() const & noexcept { return get_score_impl<2>(*this); }
    decltype(auto) vertical_score() && noexcept { return get_score_impl<2>(std::move(*this)); }
    decltype(auto) vertical_score() const && noexcept
    {
#if SEQAN3_WORKAROUND_GCC_94967
        // A simple std::move(...) does not work, because it would mess up tuple_element types like `int const &`
        using return_t = std::tuple_element_t<2, score_cell_type>;
        return static_cast<return_t const &&>(get_score_impl<2>(std::move(*this)));
#else // ^^^ workaround / no workaround vvv
        return get_score_impl<2>(std::move(*this));
#endif // SEQAN3_WORKAROUND_GCC_94967
    }
 
    decltype(auto) best_trace() & noexcept
        requires affine_score_and_trace_cell<tuple_t>
    {
        return get_trace_impl<0>(*this);
    }
    decltype(auto) best_trace() const & noexcept
        requires affine_score_and_trace_cell<tuple_t>
    {
        return get_trace_impl<0>(*this);
    }
    decltype(auto) best_trace() && noexcept
        requires affine_score_and_trace_cell<tuple_t>
    {
        return get_trace_impl<0>(std::move(*this));
    }
    decltype(auto) best_trace() const && noexcept
        requires affine_score_and_trace_cell<tuple_t>
    {
#if SEQAN3_WORKAROUND_GCC_94967
        // A simple std::move(...) does not work, because it would mess up tuple_element types like `int const &`
        using return_t = std::tuple_element_t<0, trace_cell_type>;
        return static_cast<return_t const &&>(get_trace_impl<0>(std::move(*this)));
#else // ^^^ workaround / no workaround vvv
        return get_trace_impl<0>(std::move(*this));
#endif // SEQAN3_WORKAROUND_GCC_94967
    }
 
    decltype(auto) horizontal_trace() & noexcept
        requires affine_score_and_trace_cell<tuple_t>
    {
        return get_trace_impl<1>(*this);
    }
    decltype(auto) horizontal_trace() const & noexcept
        requires affine_score_and_trace_cell<tuple_t>
    {
        return get_trace_impl<1>(*this);
    }
    decltype(auto) horizontal_trace() && noexcept
        requires affine_score_and_trace_cell<tuple_t>
    {
        return get_trace_impl<1>(std::move(*this));
    }
    decltype(auto) horizontal_trace() const && noexcept
        requires affine_score_and_trace_cell<tuple_t>
    {
#if SEQAN3_WORKAROUND_GCC_94967
        // A simple std::move(...) does not work, because it would mess up tuple_element types like `int const &`
        using return_t = std::tuple_element_t<1, trace_cell_type>;
        return static_cast<return_t const &&>(get_trace_impl<1>(std::move(*this)));
#else // ^^^ workaround / no workaround vvv
        return get_trace_impl<1>(std::move(*this));
#endif // SEQAN3_WORKAROUND_GCC_94967
    }
 
    decltype(auto) vertical_trace() & noexcept
        requires affine_score_and_trace_cell<tuple_t>
    {
        return get_trace_impl<2>(*this);
    }
    decltype(auto) vertical_trace() const & noexcept
        requires affine_score_and_trace_cell<tuple_t>
    {
        return get_trace_impl<2>(*this);
    }
    decltype(auto) vertical_trace() && noexcept
        requires affine_score_and_trace_cell<tuple_t>
    {
        return get_trace_impl<2>(std::move(*this));
    }
    decltype(auto) vertical_trace() const && noexcept
        requires affine_score_and_trace_cell<tuple_t>
    {
#if SEQAN3_WORKAROUND_GCC_94967
        // A simple std::move(...) does not work, because it would mess up tuple_element types like `int const &`
        using return_t = std::tuple_element_t<2, trace_cell_type>;
        return static_cast<return_t const &&>(get_trace_impl<2>(std::move(*this)));
#else // ^^^ workaround / no workaround vvv
        return get_trace_impl<2>(std::move(*this));
#endif // SEQAN3_WORKAROUND_GCC_94967
    }
 
private:
    template <size_t index, typename this_t>
        requires (index < 3)
    static constexpr decltype(auto) get_score_impl(this_t && me) noexcept
    {
        using std::get;
 
        if constexpr (affine_score_cell<tuple_t>)
            return get<index>(std::forward<this_t>(me));
        else
            return get<index>(get<0>(std::forward<this_t>(me)));
    }
 
    template <size_t index, typename this_t>
        requires (index < 3 && affine_score_and_trace_cell<tuple_t>)
    static constexpr decltype(auto) get_trace_impl(this_t && me) noexcept
    {
        using std::get;
 
        return get<index>(get<1>(std::forward<this_t>(me)));
    }
 
    tuple_t & as_base() & noexcept
    {
        return static_cast<tuple_t &>(*this);
    }
};
} // namespace seqan3::detail
 
namespace std
{
template <typename tuple_t>
    requires (seqan3::detail::affine_score_cell<tuple_t> || seqan3::detail::affine_score_and_trace_cell<tuple_t>)
struct tuple_size<seqan3::detail::affine_cell_proxy<tuple_t>> : public tuple_size<tuple_t>
{};
 
template <size_t index, typename tuple_t>
    requires (seqan3::detail::affine_score_cell<tuple_t> || seqan3::detail::affine_score_and_trace_cell<tuple_t>)
struct tuple_element<index, seqan3::detail::affine_cell_proxy<tuple_t>> : public tuple_element<index, tuple_t>
{};
} // namespace std