max_error_rate.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 <range/v3/numeric/accumulate.hpp>
 
#include <seqan3/core/algorithm/configuration.hpp>
#include <seqan3/core/algorithm/pipeable_config_element.hpp>
#include <seqan3/core/detail/pack_algorithm.hpp>
#include <seqan3/range/views/slice.hpp>
#include <seqan3/search/configuration/detail.hpp>
#include <seqan3/search/configuration/max_error_common.hpp>
#include <seqan3/std/algorithm>
 
namespace seqan3::search_cfg
{
 
template <typename ...errors_t>
    requires sizeof...(errors_t) <= 4 &&
            ((detail::is_type_specialisation_of_v<std::remove_reference_t<errors_t>, total> ||
              detail::is_type_specialisation_of_v<std::remove_reference_t<errors_t>, substitution> ||
              detail::is_type_specialisation_of_v<std::remove_reference_t<errors_t>, deletion>  ||
              detail::is_type_specialisation_of_v<std::remove_reference_t<errors_t>, insertion>) && ...)
class max_error_rate : public pipeable_config_element<max_error_rate<errors_t...>, std::array<double, 4>>
{
 
    using base_t = pipeable_config_element<max_error_rate<errors_t...>, std::array<double, 4>>;
 
    template <typename ..._errors_t>
    static constexpr bool check_consistency(_errors_t ...errors)
    {
        if constexpr (sizeof...(errors) < 2)
        {
            return true;
        }
        else
        {
            return [] (auto head, auto ...tail) constexpr
            {
                using head_t = decltype(head);
                if constexpr (((head_t::_id != decltype(tail)::_id) && ...))
                    return check_consistency(tail...);
                else
                    return false;
            }(errors...);
        }
    }
 
    static_assert(check_consistency(errors_t{}...),
                  "You may not use the same error specifier more than once.");
 
public:
 
    static constexpr detail::search_config_id id{detail::search_config_id::max_error_rate};
 
 
    constexpr max_error_rate()                                   noexcept = default; 
    constexpr max_error_rate(max_error_rate const &)             noexcept = default; 
    constexpr max_error_rate(max_error_rate &&)                  noexcept = default; 
    constexpr max_error_rate & operator=(max_error_rate const &) noexcept = default; 
    constexpr max_error_rate & operator=(max_error_rate &&)      noexcept = default; 
    ~max_error_rate()                                            noexcept = default; 
 
    constexpr max_error_rate(errors_t && ...errors)
        requires sizeof...(errors_t) > 0
        : base_t{}
    {
        detail::for_each([this](auto e)
        {
            base_t::value[remove_cvref_t<decltype(e)>::_id()] = e.get();
        }, std::forward<errors_t>(errors)...);
 
        // check correct values.
        std::ranges::for_each(base_t::value, [](auto error_elem)
        {
            if (0.0 > error_elem  || error_elem > 1.0)
                throw std::invalid_argument("Error rates must be between 0 and 1.");
        });
 
        // Only total is set so we set all other errors to the total limit.
        if constexpr (((std::remove_reference_t<errors_t>::_id() == 0) || ...) && sizeof...(errors) == 1)
        {
            std::ranges::fill(base_t::value | views::slice(1, 4), base_t::value[0]);
        } // otherwise if total is not set but any other field is set than use total as the sum of all set errors.
        else if constexpr (!((std::remove_reference_t<errors_t>::_id() == 0) || ...) && sizeof...(errors) > 0)
        {
            base_t::value[0] = std::min(1., ranges::accumulate(base_t::value | views::slice(1, 4), .0));
        }
    }
};
 
max_error_rate() -> max_error_rate<>;
 
template <typename ...errors_t>
max_error_rate(errors_t && ...) -> max_error_rate<remove_cvref_t<errors_t>...>;
 
} // namespace seqan3::search_cfg