align_config_aligned_ends.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 <tuple>
 
#include <seqan3/alignment/configuration/detail.hpp>
#include <seqan3/core/algorithm/pipeable_config_element.hpp>
#include <seqan3/core/detail/pack_algorithm.hpp>
#include <seqan3/core/type_traits/basic.hpp>
#include <seqan3/core/type_traits/template_inspection.hpp>
 
namespace seqan3
{
 
template <typename value_t,
          bool _is_static  = std::conditional_t<std::is_same_v<value_t, bool>, std::false_type, std::true_type>::value,
          bool _value      = std::conditional_t<_is_static, value_t, std::false_type>::value>
    requires std::same_as<value_t, std::true_type> || std::same_as<value_t, std::false_type> || std::same_as<value_t, bool>
struct sequence_end_gap_specifier_base
{
protected:
 
    template <typename ...ends_t>
    friend class end_gaps;
 
    static constexpr bool is_static    = _is_static;
    static constexpr bool static_value = _value;
 
public:
 
    constexpr bool operator()() const noexcept
    {
        return value;
    }
 
    value_t value{};
};
 
// ----------------------------------------------------------------------------
// front_end_first
// ----------------------------------------------------------------------------
 
template <typename value_t>
struct front_end_first : public sequence_end_gap_specifier_base<value_t>
{
    static constexpr std::integral_constant<uint8_t, 0> id{};
};
 
template <typename value_t>
front_end_first(value_t) -> front_end_first<value_t>;
 
// ----------------------------------------------------------------------------
// back_end_first
// ----------------------------------------------------------------------------
 
template <typename value_t>
struct back_end_first : public sequence_end_gap_specifier_base<value_t>
{
    static constexpr std::integral_constant<uint8_t, 1> id{};
};
 
template <typename value_t>
back_end_first(value_t) -> back_end_first<value_t>;
 
// ----------------------------------------------------------------------------
// front_end_second
// ----------------------------------------------------------------------------
 
template <typename value_t>
struct front_end_second : public sequence_end_gap_specifier_base<value_t>
{
    static constexpr std::integral_constant<uint8_t, 2> id{};
};
 
template <typename value_t>
front_end_second(value_t) -> front_end_second<value_t>;
 
// ----------------------------------------------------------------------------
// back_end_second
// ----------------------------------------------------------------------------
 
template <typename value_t>
struct back_end_second : public sequence_end_gap_specifier_base<value_t>
{
    static constexpr std::integral_constant<uint8_t, 3> id{};
};
 
template <typename value_t>
back_end_second(value_t) -> back_end_second<value_t>;
 
// ----------------------------------------------------------------------------
// end_gaps
// ----------------------------------------------------------------------------
 
template <typename ...ends_t>
    requires sizeof...(ends_t) <= 4 &&
             ((detail::is_type_specialisation_of_v<ends_t, front_end_first> ||
               detail::is_type_specialisation_of_v<ends_t, back_end_first> ||
               detail::is_type_specialisation_of_v<ends_t, front_end_second>  ||
               detail::is_type_specialisation_of_v<ends_t, back_end_second>) && ...)
class end_gaps
{
    template <typename ..._ends_t>
    static constexpr bool check_consistency(_ends_t ...ends)
    {
        if constexpr (sizeof...(ends) < 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;
            }(ends...);
        }
    }
 
    static_assert(check_consistency(ends_t{}...),
                  "You may not use the same end_gap specifier more than once.");
 
public:
    constexpr end_gaps() noexcept
    {
        [[maybe_unused]] auto dummy = ((values[std::remove_reference_t<ends_t>::id()] =
            std::remove_reference_t<ends_t>::static_value), ..., 0);
    }
 
    constexpr end_gaps(end_gaps const &)             noexcept = default; 
    constexpr end_gaps(end_gaps &&)                  noexcept = default; 
    constexpr end_gaps & operator=(end_gaps const &) noexcept = default; 
    constexpr end_gaps & operator=(end_gaps &&)      noexcept = default; 
    ~end_gaps()                                      noexcept = default; 
 
    constexpr end_gaps(ends_t const ...args) noexcept
        requires sizeof...(ends_t) > 0
    {
        detail::for_each([this](auto e)
        {
            values[remove_cvref_t<decltype(e)>::id()] = e();
        }, args...);
    }
    //\!}
 
    constexpr bool operator[](size_t const pos) const noexcept
    {
        assert(pos < values.size());
        return values[pos];
    }
 
    template <size_t pos>
    static constexpr bool get_static() noexcept
    {
        static_assert(is_static_array[pos],
                      "You may not access an element that was not set in a core constant expression.");
        return get<pos>(static_values);
    }
 
    template <size_t pos>
    static constexpr bool is_static() noexcept
    {
        return get<pos>(is_static_array);
    }
 
private:
 
    std::array<bool, 4> values{false, false, false, false};
 
    static constexpr std::array<bool, 4> is_static_array
    {
        [](auto ...ends) constexpr
        {
            std::array<bool, 4> tmp{false, false, false, false};
            detail::for_each([&tmp](auto v)
            {
                tmp[decltype(v)::id()] = decltype(v)::is_static;
            }, ends...);
            return tmp;
        }(ends_t{}...)
    };
 
    static constexpr std::array<bool, 4> static_values
    {
        [](auto ...ends) constexpr
        {
            std::array<bool, 4> tmp{false, false, false, false};
            detail::for_each([&tmp](auto v)
            {
                tmp[decltype(v)::id()] = decltype(v)::static_value;
            }, ends...);
            return tmp;
        }(ends_t{}...)
    };
};
 
template <typename ...ends_t>
end_gaps(ends_t const & ...) -> end_gaps<ends_t...>;
 
// ----------------------------------------------------------------------------
// free_ends_all
// ----------------------------------------------------------------------------
 
inline constexpr end_gaps free_ends_all{front_end_first<std::true_type>{},
                                        back_end_first<std::true_type>{},
                                        front_end_second<std::true_type>{},
                                        back_end_second<std::true_type>{}};
 
// ----------------------------------------------------------------------------
// free_ends_none
// ----------------------------------------------------------------------------
 
inline constexpr end_gaps free_ends_none{front_end_first<std::false_type>{},
                                         back_end_first<std::false_type>{},
                                         front_end_second<std::false_type>{},
                                         back_end_second<std::false_type>{}};
 
// ----------------------------------------------------------------------------
// free_ends_first
// ----------------------------------------------------------------------------
 
inline constexpr end_gaps free_ends_first{front_end_first<std::true_type>{},
                                          back_end_first<std::true_type>{},
                                          front_end_second<std::false_type>{},
                                          back_end_second<std::false_type>{}};
 
// ----------------------------------------------------------------------------
// free_ends_second
// ----------------------------------------------------------------------------
 
inline constexpr end_gaps free_ends_second{front_end_first<std::false_type>{},
                                           back_end_first<std::false_type>{},
                                           front_end_second<std::true_type>{},
                                           back_end_second<std::true_type>{}};
} // namespace seqan3
 
namespace seqan3::align_cfg
{
 
// ----------------------------------------------------------------------------
// aligned_ends
// ----------------------------------------------------------------------------
 
template <typename end_gaps_t>
    requires detail::is_type_specialisation_of_v<end_gaps_t, end_gaps>
struct aligned_ends : public pipeable_config_element<aligned_ends<end_gaps_t>, end_gaps_t>
{
    static constexpr detail::align_config_id id{detail::align_config_id::aligned_ends};
};
 
template <typename end_gaps_t>
aligned_ends(end_gaps_t) -> aligned_ends<std::remove_reference_t<end_gaps_t>>;
 
} // namespace seqan3::align_cfg