alphabet_variant.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 <algorithm>
#include <array>
#include <utility>
#include <cassert>
#include <variant>
 
#include <meta/meta.hpp>
 
#include <seqan3/alphabet/alphabet_base.hpp>
#include <seqan3/alphabet/composite/detail.hpp>
#include <seqan3/core/type_list/traits.hpp>
#include <seqan3/core/type_traits/lazy.hpp>
#include <seqan3/core/type_traits/pack.hpp>
#include <seqan3/core/tuple_utility.hpp>
 
namespace seqan3::detail
{
 
#if SEQAN3_WORKAROUND_GCC7_AND_8_CONCEPT_ISSUES
template <typename t>
SEQAN3_CONCEPT variant_guard_pseudoalphabet = requires { requires seqan3::alphabet_size<t> > 0; };
#endif // SEQAN3_WORKAROUND_GCC7_AND_8_CONCEPT_ISSUES
 
template <typename other_t, typename ... alternative_types>
inline constexpr bool variant_general_guard =
        (!std::same_as<other_t,      alphabet_variant<alternative_types...>>) &&
        (!std::is_base_of_v<alphabet_variant<alternative_types...>, other_t>) &&
        (!(std::same_as<other_t,     alternative_types> || ...)) &&
        (!list_traits::contains<alphabet_variant<alternative_types...>, recursive_required_types_t<other_t>>)
#if SEQAN3_WORKAROUND_GCC7_AND_8_CONCEPT_ISSUES
        && variant_guard_pseudoalphabet<other_t>
#endif // SEQAN3_WORKAROUND_GCC7_AND_8_CONCEPT_ISSUES
        ;
 
template <typename lhs_t, typename rhs_t, bool lhs_rhs_switched, typename ... alternative_types>
inline constexpr bool variant_comparison_guard =
    (instantiate_if_v<lazy<weakly_equality_comparable_with_trait, rhs_t, alternative_types>,
                      (std::same_as<lhs_t, alphabet_variant<alternative_types...>>) &&
                      (variant_general_guard<rhs_t, alternative_types...>)          &&
                      !(lhs_rhs_switched && is_type_specialisation_of_v<rhs_t, alphabet_variant>)
                      > || ...);
} // namespace seqan3::detail
 
namespace seqan3
{
 
template <typename ...alternative_types>
    requires (detail::writable_constexpr_alphabet<alternative_types> && ...) &&
             (std::regular<alternative_types> && ...) &&
             (sizeof...(alternative_types) >= 2)
             //TODO same char_type
class alphabet_variant : public alphabet_base<alphabet_variant<alternative_types...>,
                                               (static_cast<size_t>(alphabet_size<alternative_types>) + ...),
                                               char> //TODO underlying char t
 
{
private:
    using base_t = alphabet_base<alphabet_variant<alternative_types...>,
                                                   (static_cast<size_t>(alphabet_size<alternative_types>) + ...),
                                                   char>;
    friend base_t;
 
    using alternatives = meta::list<alternative_types...>;
 
    static_assert(std::same_as<alternatives, meta::unique<alternatives>>,
                  "All types in a alphabet_variant must be distinct.");
 
    using typename base_t::char_type;
    using typename base_t::rank_type;
public:
    using base_t::alphabet_size;
    using base_t::to_char;
    using base_t::to_rank;
    using base_t::assign_rank;
 
    using seqan3_required_types = type_list<alternative_types...>;
    using seqan3_recursive_required_types =
        list_traits::concat<seqan3_required_types,
                            detail::transformation_trait_or_t<detail::recursive_required_types<alternative_types>,
                                                              type_list<>>...>;
 
    template <typename alternative_t>
    static constexpr bool holds_alternative() noexcept
    {
        return detail::type_in_pack_v<alternative_t, alternative_types...>;
    }
 
    constexpr alphabet_variant()                                     noexcept = default; 
    constexpr alphabet_variant(alphabet_variant const &)             noexcept = default; 
    constexpr alphabet_variant(alphabet_variant &&)                  noexcept = default; 
    constexpr alphabet_variant & operator=(alphabet_variant const &) noexcept = default; 
    constexpr alphabet_variant & operator=(alphabet_variant &&)      noexcept = default; 
    ~alphabet_variant()                                              noexcept = default; 
 
    template <typename alternative_t>
        requires (!std::same_as<alternative_t, alphabet_variant>) &&
                 (!std::is_base_of_v<alphabet_variant, alternative_t>) &&
                 (!list_traits::contains<alphabet_variant,
                  detail::transformation_trait_or_t<detail::recursive_required_types<alternative_t>, type_list<>>>) &&
                 (holds_alternative<alternative_t>())
    constexpr alphabet_variant(alternative_t const alternative) noexcept
    {
        assign_rank(rank_by_type_(alternative));
    }
 
    template <typename indirect_alternative_t>
        requires ((detail::instantiate_if_v<
                        detail::lazy<std::is_convertible, indirect_alternative_t, alternative_types>,
                        detail::variant_general_guard<indirect_alternative_t, alternative_types...>> || ...))
    constexpr alphabet_variant(indirect_alternative_t const rhs) noexcept
    {
        assign_rank(
            rank_by_type_(
                meta::front<meta::find_if<alternatives,
                                          detail::implicitly_convertible_from<indirect_alternative_t>>>(rhs)));
    }
 
    template <typename indirect_alternative_t>
        requires ((!(detail::instantiate_if_v<
                        detail::lazy<std::is_convertible, indirect_alternative_t, alternative_types>,
                        detail::variant_general_guard<indirect_alternative_t, alternative_types...>> || ...)) &&
                    (detail::instantiate_if_v<
                        detail::lazy<std::is_constructible, alternative_types, indirect_alternative_t>,
                        detail::variant_general_guard<indirect_alternative_t, alternative_types...>> || ...))
    constexpr explicit alphabet_variant(indirect_alternative_t const rhs) noexcept
    {
        assign_rank(rank_by_type_(meta::front<meta::find_if<alternatives,
                                                            detail::constructible_from<indirect_alternative_t>>>(rhs)));
    }
 
 
    template <typename indirect_alternative_t>
        requires (detail::variant_general_guard<indirect_alternative_t, alternative_types...> &&
                  (weakly_assignable_from<alternative_types, indirect_alternative_t> || ...))
    constexpr alphabet_variant & operator=(indirect_alternative_t const & rhs) noexcept
    {
        using alternative_t = meta::front<meta::find_if<alternatives, detail::assignable_from<indirect_alternative_t>>>;
        alternative_t alternative{};
        alternative = rhs;
        assign_rank(rank_by_type_(alternative));
        return *this;
    }
 
    template <size_t index>
    constexpr bool is_alternative() const noexcept
    {
        static_assert(index < alphabet_size, "The alphabet_variant contains less alternatives than you are checking.");
        return (to_rank() >= partial_sum_sizes[index]) && (to_rank() < partial_sum_sizes[index + 1]);
    }
 
    template <size_t index>
    constexpr auto convert_to() const
    {
        return convert_impl<index, true>();
    }
 
    template <size_t index>
    constexpr auto convert_unsafely_to() const noexcept
    {
        return convert_impl<index, false>();
    }
 
    template <typename alternative_t>
    constexpr bool is_alternative() const noexcept
        requires (holds_alternative<alternative_t>())
    {
        constexpr size_t index = meta::find_index<alternatives, alternative_t>::value;
        return is_alternative<index>();
    }
 
    template <typename alternative_t>
    constexpr alternative_t convert_to() const
        requires (holds_alternative<alternative_t>())
    {
        constexpr size_t index = meta::find_index<alternatives, alternative_t>::value;
        return convert_impl<index, true>();
    }
 
    template <typename alternative_t>
    constexpr alternative_t convert_unsafely_to() const noexcept
        requires (holds_alternative<alternative_t>())
    {
        constexpr size_t index = meta::find_index<alternatives, alternative_t>::value;
        return convert_impl<index, false>();
    }
 
    template <typename alphabet_variant_t, typename indirect_alternative_type>
    friend constexpr auto operator==(alphabet_variant_t const lhs, indirect_alternative_type const rhs) noexcept
        -> std::enable_if_t<detail::variant_comparison_guard<alphabet_variant_t,
                                                             indirect_alternative_type,
                                                             false,
                                                             alternative_types...>,
                            bool>
    {
        using alternative_t =
            meta::front<meta::find_if<alternatives,
                                      detail::weakly_equality_comparable_with_<indirect_alternative_type>>>;
        return lhs.template is_alternative<alternative_t>() && (lhs.template convert_unsafely_to<alternative_t>() == rhs);
    }
 
    template <typename alphabet_variant_t, typename indirect_alternative_type>
    friend constexpr auto operator!=(alphabet_variant_t const lhs, indirect_alternative_type const rhs) noexcept
        -> std::enable_if_t<detail::variant_comparison_guard<alphabet_variant_t,
                                                             indirect_alternative_type,
                                                             false,
                                                             alternative_types...>,
                            bool>
    {
        return !(lhs == rhs);
    }
 
    template <typename alphabet_variant_t, typename indirect_alternative_type, typename = void>
    friend constexpr auto operator==(indirect_alternative_type const lhs, alphabet_variant_t const rhs) noexcept
        -> std::enable_if_t<detail::variant_comparison_guard<alphabet_variant_t,
                                                             indirect_alternative_type,
                                                             true,
                                                             alternative_types...>,
                            bool>
    {
        return rhs == lhs;
    }
 
    template <typename alphabet_variant_t, typename indirect_alternative_type, typename = void>
    friend constexpr auto operator!=(indirect_alternative_type const lhs, alphabet_variant_t const rhs) noexcept
        -> std::enable_if_t<detail::variant_comparison_guard<alphabet_variant_t,
                                                             indirect_alternative_type,
                                                             true,
                                                             alternative_types...>,
                            bool>
    {
        return rhs != lhs;
    }
 
    static constexpr bool char_is_valid(char_type const chr) noexcept
    {
        bool is_valid{false};
 
        meta::for_each(alternatives{}, [&] (auto && alt)
        {
            if (char_is_valid_for<std::remove_cvref_t<decltype(alt)>>(chr))
                is_valid = true;
        });
 
        return is_valid;
    }
 
protected:
 
    template <size_t index, bool throws>
    constexpr auto convert_impl() const noexcept(!throws) -> meta::at_c<alternatives, index>
    {
        static_assert(index < alphabet_size, "The alphabet_variant contains less alternatives than you are checking.");
        using alternative_t = meta::at_c<alternatives, index>;
 
        if constexpr (throws)
        {
            if (!is_alternative<index>()) // [[unlikely]]
            {
                throw std::bad_variant_access{};
            }
        }
 
        return seqan3::assign_rank_to(to_rank() - partial_sum_sizes[index], alternative_t{});
    }
 
    static constexpr std::array<rank_type, sizeof...(alternative_types) + 1> partial_sum_sizes = []() constexpr
    {
        constexpr size_t N = sizeof...(alternative_types) + 1;
 
        std::array<rank_type, N> partial_sum{0, seqan3::alphabet_size<alternative_types>...};
        for (size_t i = 1u; i < N; ++i)
            partial_sum[i] += partial_sum[i-1];
 
        return partial_sum;
    }();
 
    static constexpr std::array<char_type, alphabet_size> rank_to_char = []() constexpr
    {
        // Explicitly writing assign_rank_to_char within assign_rank_to_char
        // causes this bug (g++-7 and g++-8):
        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84684
        auto assign_rank_to_char = [](auto alternative, size_t rank) constexpr
        {
            return seqan3::to_char(seqan3::assign_rank_to(rank, alternative));
        };
 
        auto assign_value_to_char = [assign_rank_to_char] (auto alternative, auto & value_to_char, auto & value) constexpr
        {
            using alternative_t = std::decay_t<decltype(alternative)>;
            for (size_t i = 0u; i < seqan3::alphabet_size<alternative_t>; ++i, ++value)
                value_to_char[value] = assign_rank_to_char(alternative, i);
        };
 
        unsigned value = 0u;
        std::array<char_type, alphabet_size> value_to_char{};
 
        // initializer lists guarantee sequencing;
        // the following expression behaves as:
        // for(auto alternative: alternative_types)
        //    assign_rank_to_char(alternative, rank_to_char, value);
        ((assign_value_to_char(alternative_types{}, value_to_char, value)),...);
 
        return value_to_char;
    }();
 
    template <size_t index, typename alternative_t>
        requires (holds_alternative<alternative_t>())
    static constexpr rank_type rank_by_index_(alternative_t const & alternative) noexcept
    {
        return partial_sum_sizes[index] + static_cast<rank_type>(seqan3::to_rank(alternative));
    }
 
    template <typename alternative_t>
        requires (holds_alternative<alternative_t>())
    static constexpr rank_type rank_by_type_(alternative_t const & alternative) noexcept
    {
        constexpr size_t index = meta::find_index<alternatives, alternative_t>::value;
        return rank_by_index_<index>(alternative);
    }
 
    static constexpr std::array<rank_type, detail::size_in_values_v<char_type>> char_to_rank = []() constexpr
    {
        constexpr size_t table_size = detail::size_in_values_v<char_type>;
 
        std::array<rank_type, table_size> char_to_rank{};
 
        for (size_t i = 0u; i < table_size; ++i)
        {
            char_type chr = static_cast<char_type>(i);
            bool there_was_no_valid_representation{true};
 
            meta::for_each(alternatives{}, [&] (auto && alt)
            {
                using alt_type = std::remove_cvref_t<decltype(alt)>;
 
                if (there_was_no_valid_representation && char_is_valid_for<alt_type>(chr))
                {
                    there_was_no_valid_representation = false;
                    char_to_rank[i] = rank_by_type_(assign_char_to(chr, alt_type{}));
                }
            });
 
            if (there_was_no_valid_representation)
                char_to_rank[i] = rank_by_type_(assign_char_to(chr, meta::front<alternatives>{}));
        }
 
        return char_to_rank;
    }();
};
 
} // namespace seqan3