find_optimum_policy.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 <type_traits>
 
#include <seqan3/alignment/configuration/align_config_method.hpp>
#include <seqan3/alignment/matrix/detail/alignment_optimum.hpp>
#include <seqan3/alignment/pairwise/detail/alignment_algorithm_state.hpp>
 
namespace seqan3::detail
{
 
template <typename alignment_algorithm_t>
class find_optimum_policy
{
private:
    friend alignment_algorithm_t;
 
    bool test_every_cell{false};
    bool test_last_row_cell{false};
    bool test_last_column_cell{false};
 
    constexpr find_optimum_policy() = default;                                        
    constexpr find_optimum_policy(find_optimum_policy const &) = default;             
    constexpr find_optimum_policy(find_optimum_policy &&) = default;                  
    constexpr find_optimum_policy & operator=(find_optimum_policy const &) = default; 
    constexpr find_optimum_policy & operator=(find_optimum_policy &&) = default;      
    ~find_optimum_policy() = default;                                                 
 
    template <typename configuration_t>
    find_optimum_policy(configuration_t const & config)
    {
        if constexpr (configuration_t::template exists<align_cfg::method_local>())
            test_every_cell =  true;
 
        auto method_global_config = config.get_or(align_cfg::method_global{});
        test_last_row_cell = method_global_config.free_end_gaps_sequence1_trailing;
        test_last_column_cell = method_global_config.free_end_gaps_sequence2_trailing;
    }
 
protected:
    template <typename cell_t, typename score_t>
    constexpr void check_score_of_cell([[maybe_unused]] cell_t const & current_cell,
                                       [[maybe_unused]] alignment_algorithm_state<score_t> & state) const noexcept
    {
        if (test_every_cell)
            check_and_update(current_cell, state);
    }
 
    template <typename other_alignment_algorithm_t, typename score_t, typename is_local_t>
    friend class affine_gap_policy;
 
    template <typename other_alignment_algorithm_t, simd_concept score_t, typename is_local_t>
    friend class simd_affine_gap_policy;
 
    template <typename other_alignment_algorithm_t>
    friend class affine_gap_init_policy;
 
    template <typename cell_t, typename score_t>
    constexpr void check_score_of_last_row_cell([[maybe_unused]] cell_t const & last_row_cell,
                                                [[maybe_unused]] alignment_algorithm_state<score_t> & state) const
        noexcept
    {
        // Only search in last row if requested and not done already.
        if (!test_every_cell && test_last_row_cell)
            check_and_update(last_row_cell, state);
    }
 
    template <typename alignment_column_t, typename score_t>
    constexpr void check_score_of_cells_in_last_column([[maybe_unused]] alignment_column_t && last_column,
                                                       [[maybe_unused]] alignment_algorithm_state<score_t> & state)
        const noexcept
    {
        // Only check last cell if not done before.
        if (!test_every_cell && test_last_column_cell)
            for (auto && cell : last_column)
                check_and_update(cell, state);
    }
 
    template <typename cell_t, typename score_t>
    constexpr void check_score_of_last_cell([[maybe_unused]] cell_t const & last_cell,
                                            [[maybe_unused]] alignment_algorithm_state<score_t> & state) const noexcept
    {
        // Only check last cell if not done before.
        if (!(test_every_cell || test_last_row_cell || test_last_column_cell))
            check_and_update(last_cell, state);
    }
 
    template <typename cell_t, typename score_t>
    constexpr void check_and_update(cell_t const & cell, alignment_algorithm_state<score_t> & state) const noexcept
    {
        auto const & [score_cell, trace_cell] = cell;
        state.optimum.update_if_new_optimal_score(score_cell.current,
                                                  column_index_type{trace_cell.coordinate.first},
                                                  row_index_type{trace_cell.coordinate.second});
    }
};
 
} // namespace seqan3::detail