find_optimum_policy.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/matrix/alignment_optimum.hpp>
#include <seqan3/alignment/pairwise/detail/alignment_algorithm_state.hpp>
 
namespace seqan3::detail
{
 
struct default_find_optimum_trait
{
    using find_in_every_cell_type  = std::false_type;
    using find_in_last_row_type    = std::false_type;
    using find_in_last_column_type = std::false_type;
};
 
template <typename alignment_algorithm_t, typename traits_type = default_find_optimum_trait>
class find_optimum_policy
{
private:
    friend alignment_algorithm_t;
 
    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;                                                 
 
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 constexpr (traits_type::find_in_every_cell_type::value)
            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, typename score_t, typename is_local_t>
    friend class simd_affine_gap_policy;
 
    template <typename other_alignment_algorithm_t, typename other_traits_type>
    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 constexpr (!traits_type::find_in_every_cell_type::value && traits_type::find_in_last_row_type::value)
            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 constexpr (!traits_type::find_in_every_cell_type::value && traits_type::find_in_last_column_type::value)
            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 constexpr (!traits_type::find_in_every_cell_type::value &&
                      !traits_type::find_in_last_row_type::value &&
                      !traits_type::find_in_last_column_type::value)
        {
            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