alignment_result.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 <seqan3/core/type_traits/template_inspection.hpp>
 
namespace seqan3::detail
{
 
template <typename id_t,
          typename score_t,
          typename back_coord_t = std::nullopt_t *,
          typename front_coord_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
{
    id_t id{};
    score_t score{};
    back_coord_t back_coordinate{};
    front_coord_t front_coordinate{};
    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 *>;
 
template <typename id_t, typename score_t>
alignment_result_value_type(id_t, score_t)
    -> alignment_result_value_type<id_t, score_t>;
 
template <typename id_t, typename score_t, typename back_coord_t>
alignment_result_value_type(id_t, score_t, back_coord_t)
    -> alignment_result_value_type<id_t, score_t, back_coord_t>;
 
template <typename id_t, typename score_t, typename back_coord_t, typename front_coord_t>
alignment_result_value_type(id_t, score_t, back_coord_t, front_coord_t)
    -> alignment_result_value_type<id_t, score_t, back_coord_t, front_coord_t>;
 
template <typename id_t, typename score_t, typename back_coord_t, typename front_coord_t, typename alignment_t>
alignment_result_value_type(id_t, score_t, back_coord_t, front_coord_t, alignment_t)
    -> alignment_result_value_type<id_t, score_t, back_coord_t, front_coord_t, alignment_t>;
 
} // namespace seqan3::detail
 
namespace seqan3
{
 
template <typename alignment_result_traits>
    requires detail::is_type_specialisation_of_v<alignment_result_traits, detail::alignment_result_value_type>
class alignment_result
{
private:
    alignment_result_traits data;
 
    using id_t          = decltype(data.id);
    using score_t       = decltype(data.score);
    using back_coord_t   = decltype(data.back_coordinate);
    using front_coord_t = decltype(data.front_coordinate);
    using alignment_t   = decltype(data.alignment);
 
public:
    alignment_result(alignment_result_traits value) : data(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 id_t id() const noexcept
    {
        static_assert(!std::is_same_v<id_t, std::nullopt_t *>,
                      "Identifier is not available but should.");
        return data.id;
    }
 
    constexpr score_t score() const noexcept
    {
        static_assert(!std::is_same_v<score_t, std::nullopt_t *>,
                      "Alignment score is not available but should.");
        return data.score;
    }
 
    constexpr back_coord_t const & back_coordinate() const noexcept
    {
        static_assert(!std::is_same_v<back_coord_t, std::nullopt_t *>,
                      "Trying to access the back coordinate, although it was not requested in the alignment "
                      "configuration.");
        return data.back_coordinate;
    }
 
    constexpr front_coord_t const & front_coordinate() const noexcept
    {
        static_assert(!std::is_same_v<front_coord_t, std::nullopt_t *>,
                      "Trying to access the front coordinate, although it was not requested in the alignment "
                      "configuration.");
        return data.front_coordinate;
    }
 
    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