alignment_result.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 <optional>
 
#include <seqan3/core/configuration/configuration.hpp>
#include <seqan3/core/debug_stream/debug_stream_type.hpp>
#include <seqan3/core/detail/template_inspection.hpp>
 
namespace seqan3::detail
{
 
// forward declaration for friend declaration in alignment_result.
template <typename configuration_t>
#if !SEQAN3_WORKAROUND_GCC_93467
    requires is_type_specialisation_of_v<configuration_t, configuration>
#endif // !SEQAN3_WORKAROUND_GCC_93467
class policy_alignment_result_builder;
 
template <typename sequence1_id_t,
          typename sequence2_id_t,
          typename score_t,
          typename end_positions_t = std::nullopt_t *,
          typename begin_positions_t = std::nullopt_t *,
          typename alignment_t = std::nullopt_t *,
          typename score_debug_matrix_t = std::nullopt_t *,
          typename trace_debug_matrix_t = std::nullopt_t *>
struct alignment_result_value_type
{
    sequence1_id_t sequence1_id{};
    sequence2_id_t sequence2_id{};
    score_t score{};
    end_positions_t end_positions{};
    begin_positions_t begin_positions{};
    alignment_t alignment{};
 
    score_debug_matrix_t score_debug_matrix{};
    trace_debug_matrix_t trace_debug_matrix{};
};
 
alignment_result_value_type()->alignment_result_value_type<std::nullopt_t *, std::nullopt_t *, std::nullopt_t *>;
 
template <typename sequence1_id_t, typename sequence2_id_t, typename score_t>
alignment_result_value_type(sequence1_id_t, sequence2_id_t, score_t)
    -> alignment_result_value_type<sequence1_id_t, sequence2_id_t, score_t>;
 
template <typename sequence1_id_t, typename sequence2_id_t, typename score_t, typename end_positions_t>
alignment_result_value_type(sequence1_id_t, sequence2_id_t, score_t, end_positions_t)
    -> alignment_result_value_type<sequence1_id_t, sequence2_id_t, score_t, end_positions_t>;
 
template <typename sequence1_id_t,
          typename sequence2_id_t,
          typename score_t,
          typename end_positions_t,
          typename begin_positions_t>
alignment_result_value_type(sequence1_id_t, sequence2_id_t, score_t, end_positions_t, begin_positions_t)
    -> alignment_result_value_type<sequence1_id_t, sequence2_id_t, score_t, end_positions_t, begin_positions_t>;
 
template <typename sequence1_id_t,
          typename sequence2_id_t,
          typename score_t,
          typename end_positions_t,
          typename begin_positions_t,
          typename alignment_t>
alignment_result_value_type(sequence1_id_t, sequence2_id_t, score_t, end_positions_t, begin_positions_t, alignment_t)
    -> alignment_result_value_type<sequence1_id_t,
                                   sequence2_id_t,
                                   score_t,
                                   end_positions_t,
                                   begin_positions_t,
                                   alignment_t>;
 
template <typename result_t>
struct alignment_result_value_type_accessor;
} // namespace seqan3::detail
 
namespace seqan3
{
 
template <typename alignment_result_value_t>
    requires detail::is_type_specialisation_of_v<alignment_result_value_t, detail::alignment_result_value_type>
class alignment_result
{
private:
    alignment_result_value_t data{};
 
    using sequence1_id_t = decltype(data.sequence1_id);
    using sequence2_id_t = decltype(data.sequence2_id);
    using score_t = decltype(data.score);
    using end_positions_t = decltype(data.end_positions);
    using begin_positions_t = decltype(data.begin_positions);
    using alignment_t = decltype(data.alignment);
 
    template <typename configuration_t>
#if !SEQAN3_WORKAROUND_GCC_93467
        requires detail::is_type_specialisation_of_v<configuration_t, configuration>
#endif // !SEQAN3_WORKAROUND_GCC_93467
    friend class detail::policy_alignment_result_builder;
 
public:
 
    alignment_result(alignment_result_value_t value) : data(std::move(value))
    {}
 
    alignment_result() = default;                                     
    alignment_result(alignment_result const &) = default;             
    alignment_result(alignment_result &&) = default;                  
    alignment_result & operator=(alignment_result const &) = default; 
    alignment_result & operator=(alignment_result &&) = default;      
    ~alignment_result() = default;                                    
 
 
    constexpr sequence1_id_t sequence1_id() const noexcept
    {
        static_assert(!std::is_same_v<sequence1_id_t, std::nullopt_t *>,
                      "Trying to access the id of the first sequence, although it was not requested in the"
                      " alignment configuration.");
        return data.sequence1_id;
    }
 
    constexpr sequence2_id_t sequence2_id() const noexcept
    {
        static_assert(!std::is_same_v<sequence2_id_t, std::nullopt_t *>,
                      "Trying to access the id of the second sequence, although it was not requested in the"
                      " alignment configuration.");
        return data.sequence2_id;
    }
 
    constexpr score_t score() const noexcept
    {
        static_assert(!std::is_same_v<score_t, std::nullopt_t *>,
                      "Trying to access the score, although it was not requested in the alignment configuration.");
        return data.score;
    }
 
    constexpr auto sequence1_end_position() const noexcept
    {
        static_assert(!std::is_same_v<end_positions_t, std::nullopt_t *>,
                      "Trying to access the end position of the first sequence, although it was not requested in the"
                      " alignment configuration.");
        return data.end_positions.first;
    }
 
    constexpr auto sequence2_end_position() const noexcept
    {
        static_assert(!std::is_same_v<end_positions_t, std::nullopt_t *>,
                      "Trying to access the end position of the second sequence, although it was not requested in the"
                      " alignment configuration.");
        return data.end_positions.second;
    }
 
    constexpr auto sequence1_begin_position() const noexcept
    {
        static_assert(!std::is_same_v<begin_positions_t, std::nullopt_t *>,
                      "Trying to access the begin position of the first sequence, although it was not requested in the"
                      " alignment configuration.");
        return data.begin_positions.first;
    }
 
    constexpr auto sequence2_begin_position() const noexcept
    {
        static_assert(!std::is_same_v<begin_positions_t, std::nullopt_t *>,
                      "Trying to access the begin position of the second sequence, although it was not requested in the"
                      " alignment configuration.");
        return data.begin_positions.second;
    }
 
    constexpr alignment_t const & alignment() const noexcept
    {
        static_assert(!std::is_same_v<alignment_t, std::nullopt_t *>,
                      "Trying to access the alignment, although it was not requested in the alignment configuration.");
        return data.alignment;
    }
 
 
    constexpr auto const & score_matrix() const noexcept
    {
        static_assert(
            !std::is_same_v<decltype(data.score_debug_matrix), std::nullopt_t *>,
            "Trying to access the score matrix, although it was not requested in the alignment configuration.");
        return data.score_debug_matrix;
    }
 
    constexpr auto const & trace_matrix() const noexcept
    {
        static_assert(
            !std::is_same_v<decltype(data.trace_debug_matrix), std::nullopt_t *>,
            "Trying to access the trace matrix, although it was not requested in the alignment configuration.");
        return data.trace_debug_matrix;
    }
};
} // namespace seqan3
 
namespace seqan3::detail
{
template <typename result_value_t>
struct alignment_result_value_type_accessor<alignment_result<result_value_t>>
{
    using type = result_value_t;
};
 
} // namespace seqan3::detail
 
namespace seqan3
{
template <typename char_t, typename alignment_result_t>
    requires detail::is_type_specialisation_of_v<std::remove_cvref_t<alignment_result_t>, alignment_result>
inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & stream, alignment_result_t && result)
{
    using disabled_t = std::nullopt_t *;
    using result_data_t =
        typename detail::alignment_result_value_type_accessor<std::remove_cvref_t<alignment_result_t>>::type;
 
    constexpr bool has_sequence1_id = !std::is_same_v<decltype(std::declval<result_data_t>().sequence1_id), disabled_t>;
    constexpr bool has_sequence2_id = !std::is_same_v<decltype(std::declval<result_data_t>().sequence2_id), disabled_t>;
    constexpr bool has_score = !std::is_same_v<decltype(std::declval<result_data_t>().score), disabled_t>;
    constexpr bool has_end_positions =
        !std::is_same_v<decltype(std::declval<result_data_t>().end_positions), disabled_t>;
    constexpr bool has_begin_positions =
        !std::is_same_v<decltype(std::declval<result_data_t>().begin_positions), disabled_t>;
    constexpr bool has_alignment = !std::is_same_v<decltype(std::declval<result_data_t>().alignment), disabled_t>;
 
    bool prepend_comma = false;
    auto append_to_stream = [&](auto &&... args)
    {
        ((stream << (prepend_comma ? std::string{", "} : std::string{})) << ... << std::forward<decltype(args)>(args));
        prepend_comma = true;
    };
 
    stream << '{';
    if constexpr (has_sequence1_id)
        append_to_stream("sequence1 id: ", result.sequence1_id());
    if constexpr (has_sequence2_id)
        append_to_stream("sequence2 id: ", result.sequence2_id());
    if constexpr (has_score)
        append_to_stream("score: ", result.score());
    if constexpr (has_begin_positions)
        append_to_stream("begin: (", result.sequence1_begin_position(), ",", result.sequence2_begin_position(), ")");
    if constexpr (has_end_positions)
        append_to_stream("end: (", result.sequence1_end_position(), ",", result.sequence2_end_position(), ")");
    if constexpr (has_alignment)
        append_to_stream("\nalignment:\n", result.alignment());
    stream << '}';
 
    return stream;
}
} // namespace seqan3