type_traits.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 <type_traits>
 
#include <seqan3/alignment/configuration/align_config_result_type.hpp>
#include <seqan3/alignment/configuration/align_config_band.hpp>
#include <seqan3/alignment/configuration/align_config_debug.hpp>
#include <seqan3/alignment/configuration/align_config_method.hpp>
#include <seqan3/alignment/configuration/align_config_on_result.hpp>
#include <seqan3/alignment/configuration/align_config_output.hpp>
#include <seqan3/alignment/configuration/align_config_parallel.hpp>
#include <seqan3/alignment/configuration/align_config_score_type.hpp>
#include <seqan3/alignment/configuration/align_config_scoring_scheme.hpp>
#include <seqan3/alignment/configuration/align_config_vectorised.hpp>
#include <seqan3/alignment/matrix/detail/matrix_coordinate.hpp>
#include <seqan3/alignment/matrix/trace_directions.hpp>
#include <seqan3/alignment/pairwise/detail/concept.hpp>
#include <seqan3/core/algorithm/configuration.hpp>
#include <seqan3/core/bit_manipulation.hpp>
#include <seqan3/core/detail/empty_type.hpp>
#include <seqan3/core/simd/simd_traits.hpp>
#include <seqan3/core/simd/simd.hpp>
#include <seqan3/core/type_traits/function.hpp>
#include <seqan3/core/type_traits/lazy.hpp>
#include <seqan3/core/type_traits/template_inspection.hpp>
#include <seqan3/range/views/chunk.hpp>
#include <seqan3/range/views/zip.hpp>
#include <seqan3/std/ranges>
 
namespace seqan3::detail
{
 
//------------------------------------------------------------------------------
// chunked_indexed_sequence_pairs
//------------------------------------------------------------------------------
 
template <typename sequence_pairs_t>
    requires sequence_pair_range<std::remove_reference_t<sequence_pairs_t>>
struct chunked_indexed_sequence_pairs
{
    using type = decltype(views::zip(std::declval<sequence_pairs_t>(), std::views::iota(0)) | views::chunk(1));
};
 
//------------------------------------------------------------------------------
// alignment_configuration_traits
//------------------------------------------------------------------------------
 
template <typename configuration_t>
    requires is_type_specialisation_of_v<std::remove_cv_t<configuration_t>, configuration>
struct alignment_configuration_traits
{
private:
    template <arithmetic score_t>
    using select_scalar_index_t = min_viable_uint_t<1ull << (sizeof_bits<score_t> - 1)>;
 
    static constexpr auto determine_alignment_result_type() noexcept
    {
        if constexpr (configuration_t::template exists<align_cfg::detail::result_type>())
        {
            using result_type_cfg_t =
                std::remove_cvref_t<
                    decltype(seqan3::get<align_cfg::detail::result_type>(std::declval<configuration_t>()))
                >;
            return typename result_type_cfg_t::type{};  // Access the stored result_type.
        }
        else
        {
            return empty_type{};
        }
    }
 
public:
    static constexpr bool is_vectorised = configuration_t::template exists<align_cfg::vectorised>();
    static constexpr bool is_parallel = configuration_t::template exists<align_cfg::parallel>();
    static constexpr bool is_global =
        configuration_t::template exists<seqan3::align_cfg::method_global>();
    static constexpr bool is_local = configuration_t::template exists<seqan3::align_cfg::method_local>();
    static constexpr bool is_banded = configuration_t::template exists<align_cfg::band_fixed_size>();
    static constexpr bool is_debug = configuration_t::template exists<detail::debug_mode>();
    static constexpr bool is_one_way_execution = configuration_t::template exists<align_cfg::on_result>();
    using scoring_scheme_type = decltype(get<align_cfg::scoring_scheme>(std::declval<configuration_t>()).scheme);
    using scoring_scheme_alphabet_type = typename scoring_scheme_type::alphabet_type;
    using original_score_type = typename std::remove_reference_t<decltype(
        std::declval<configuration_t>().get_or(align_cfg::score_type<int32_t>{}))>::type;
    using score_type = std::conditional_t<is_vectorised, simd_type_t<original_score_type>, original_score_type>;
    using trace_type = std::conditional_t<is_vectorised, simd_type_t<original_score_type>, trace_directions>;
    using alignment_result_type = decltype(determine_alignment_result_type());
    using matrix_index_type = std::conditional_t<is_vectorised,
                                                 simd_type_t<select_scalar_index_t<original_score_type>>,
                                                 size_t>;
    using matrix_coordinate_type = lazy_conditional_t<is_vectorised,
                                                      lazy<simd_matrix_coordinate, matrix_index_type>,
                                                      matrix_coordinate>;
 
    static constexpr size_t alignments_per_vector = [] () constexpr
                                                    {
                                                        if constexpr (is_vectorised)
                                                            return simd_traits<score_type>::length;
                                                        else
                                                            return 1;
                                                    }();
    static constexpr bool compute_score = configuration_t::template exists<align_cfg::output_score>();
    static constexpr bool compute_end_positions =
        configuration_t::template exists<align_cfg::output_end_position>();
    static constexpr bool compute_begin_positions =
        configuration_t::template exists<align_cfg::output_begin_position>();
    static constexpr bool compute_sequence_alignment =
        configuration_t::template exists<align_cfg::output_alignment>();
    static constexpr bool output_sequence1_id =
        configuration_t::template exists<align_cfg::output_sequence1_id>();
    static constexpr bool output_sequence2_id =
        configuration_t::template exists<align_cfg::output_sequence2_id>();
    static constexpr bool has_output_configuration = compute_score ||
                                                     compute_end_positions ||
                                                     compute_begin_positions ||
                                                     compute_sequence_alignment ||
                                                     output_sequence1_id ||
                                                     output_sequence2_id;
    static constexpr original_score_type padding_symbol =
        static_cast<original_score_type>(1u << (sizeof_bits<original_score_type> - 1));
};
 
//------------------------------------------------------------------------------
// alignment_function_traits
//------------------------------------------------------------------------------
 
template <typename function_t>
struct alignment_function_traits
{
    using sequence_input_type = typename function_traits<function_t>::template argument_type_at<0>;
    using callback_type = typename function_traits<function_t>::template argument_type_at<1>;
    using alignment_result_type = typename function_traits<callback_type>::template argument_type_at<0>;
};
 
}  // namespace seqan3::detail