alphabet_tuple_base.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 <cassert>
#include <utility>
 
#include <meta/meta.hpp>
 
#include <seqan3/alphabet/concept.hpp>
#include <seqan3/alphabet/composite/detail.hpp>
#include <seqan3/alphabet/alphabet_base.hpp>
#include <seqan3/alphabet/detail/alphabet_proxy.hpp>
#include <seqan3/alphabet/quality/concept.hpp>
#include <seqan3/core/concept/core_language.hpp>
#include <seqan3/core/concept/tuple.hpp>
#include <seqan3/core/detail/debug_stream_type.hpp>
#include <seqan3/core/detail/int_types.hpp>
#include <seqan3/core/type_traits/pack.hpp>
#include <seqan3/core/type_traits/transformation_trait_or.hpp>
#include <seqan3/core/tuple_utility.hpp>
#include <seqan3/std/concepts>
 
namespace seqan3::detail
{
 
template <typename tuple_derived_t, typename rhs_t, typename ... component_types>
inline constexpr bool tuple_general_guard =
                      (!std::same_as<rhs_t, tuple_derived_t>) &&
                      (!std::same_as<rhs_t, alphabet_tuple_base<component_types...>>) &&
                      (!std::is_base_of_v<tuple_derived_t, rhs_t>) &&
                      (!(std::same_as<rhs_t, component_types> || ...)) &&
                      (!list_traits::contains<tuple_derived_t, recursive_required_types_t<rhs_t>>);
 
 
template <typename lhs_t, typename tuple_derived_t, typename rhs_t, typename ... component_types>
inline constexpr bool tuple_eq_guard =
    (instantiate_if_v<lazy<weakly_equality_comparable_with_trait, rhs_t, component_types>,
                      std::same_as<lhs_t, tuple_derived_t> &&
                      tuple_general_guard<tuple_derived_t, rhs_t, component_types...>
                      > || ...);
 
template <typename lhs_t, typename tuple_derived_t, typename rhs_t, typename ... component_types>
inline constexpr bool tuple_order_guard =
    (instantiate_if_v<lazy<weakly_ordered_with_trait, rhs_t, component_types>,
                      std::same_as<lhs_t, tuple_derived_t> &&
                      tuple_general_guard<lhs_t, tuple_derived_t, rhs_t, component_types...>
                      > || ...);
 
} // namespace seqan3::detail
 
namespace seqan3
{
 
// forwards
template <typename t>
decltype(auto) get();
 
template <size_t i>
decltype(auto) get();
 
template <typename derived_type,
          typename ...component_types>
    requires (detail::writable_constexpr_semialphabet<component_types> && ...) &&
             (std::regular<component_types> && ...)
class alphabet_tuple_base :
    public alphabet_base<derived_type,
                         (1 * ... * alphabet_size<component_types>),
                         void> // no char type, because this is only semi_alphabet
{
private:
    using base_t = alphabet_base<derived_type,
                                (1 * ... * alphabet_size<component_types>),
                                void>; // no char type, because this is only semi_alphabet
 
    using component_list = meta::list<component_types...>;
 
    template <typename type>
    static constexpr bool is_component =
        meta::in<component_list, type>::value;
 
    template <typename type>
    static constexpr bool is_unique_component =
        is_component<type> &&
        (meta::find_index<component_list, type>::value == meta::reverse_find_index<component_list, type>::value);
 
    template <typename alphabet_type, size_t index>
    class component_proxy : public alphabet_proxy<component_proxy<alphabet_type, index>, alphabet_type>
    {
    private:
        using base_t = alphabet_proxy<component_proxy<alphabet_type, index>, alphabet_type>;
        friend base_t;
 
        alphabet_tuple_base *parent;
 
        constexpr void on_update() noexcept
        {
            parent->assign_component_rank<index>(to_rank());
        }
 
    public:
        //Import from base type:
        using base_t::operator=;
 
        component_proxy() = delete;
        constexpr component_proxy(component_proxy const &) = default;              
        constexpr component_proxy(component_proxy &&) = default;                   
        constexpr component_proxy & operator=(component_proxy const &) = default;  
        constexpr component_proxy & operator=(component_proxy &&) = default;       
        ~component_proxy() = default;                                              
 
        constexpr component_proxy(alphabet_type const l, alphabet_tuple_base & p) :
            base_t{l}, parent{&p}
        {}
 
        // Does not inherit the base's constructor for alphabet_type so as not to cause ambiguity
 
        friend constexpr bool operator==(derived_type const lhs, component_proxy const rhs) noexcept
        {
            return get<index>(lhs) == static_cast<alphabet_type>(rhs);
        }
 
        friend constexpr bool operator==(component_proxy<alphabet_type, index> const lhs, derived_type const rhs) noexcept
        {
            return rhs == lhs;
        }
 
        friend constexpr bool operator!=(derived_type const lhs, component_proxy const rhs) noexcept
        {
            return get<index>(lhs) != static_cast<alphabet_type>(rhs);
        }
 
        friend constexpr bool operator!=(component_proxy<alphabet_type, index> const lhs, derived_type const rhs) noexcept
        {
            return rhs != lhs;
        }
 
        friend constexpr bool operator<(derived_type const lhs, component_proxy const rhs) noexcept
        {
            return get<index>(lhs) < static_cast<alphabet_type>(rhs);
        }
 
        friend constexpr bool operator<(component_proxy<alphabet_type, index> const lhs, derived_type const rhs) noexcept
        {
            return rhs > lhs;
        }
 
        friend constexpr bool operator<=(derived_type const lhs, component_proxy const rhs) noexcept
        {
            return get<index>(lhs) <= static_cast<alphabet_type>(rhs);
        }
 
        friend constexpr bool operator<=(component_proxy<alphabet_type, index> const lhs, derived_type const rhs) noexcept
        {
            return rhs >= lhs;
        }
 
        friend constexpr bool operator>(derived_type const lhs, component_proxy const rhs) noexcept
        {
            return get<index>(lhs) > static_cast<alphabet_type>(rhs);
        }
 
        friend constexpr bool operator>(component_proxy<alphabet_type, index> const lhs, derived_type const rhs) noexcept
        {
            return rhs < lhs;
        }
 
        friend constexpr bool operator>=(derived_type const lhs, component_proxy const rhs) noexcept
        {
            return get<index>(lhs) >= static_cast<alphabet_type>(rhs);
        }
 
        friend constexpr bool operator>=(component_proxy<alphabet_type, index> const lhs, derived_type const rhs) noexcept
        {
            return rhs <= lhs;
        }
    };
 
    constexpr alphabet_tuple_base() noexcept : base_t{} {}                            
    constexpr alphabet_tuple_base(alphabet_tuple_base const &) = default;             
    constexpr alphabet_tuple_base(alphabet_tuple_base &&) = default;                  
    constexpr alphabet_tuple_base & operator=(alphabet_tuple_base const &) = default; 
    constexpr alphabet_tuple_base & operator=(alphabet_tuple_base &&) = default;      
    ~alphabet_tuple_base() = default;                                                 
 
    using base_t::base_t;
 
    friend derived_type;
 
    // Import from base:
    using typename base_t::rank_type;
 
public:
    // Import from base:
    using base_t::alphabet_size;
    using base_t::to_rank;
    using base_t::assign_rank;
 
    using seqan3_required_types = component_list;
    using seqan3_recursive_required_types =
        meta::concat<component_list,
                     detail::transformation_trait_or_t<detail::recursive_required_types<component_types>,
                                                       meta::list<>>...>;
    static constexpr bool seqan3_alphabet_tuple_base_specialisation = true;
 
    constexpr alphabet_tuple_base(component_types ... components) noexcept
    {
        assign_rank(rank_sum_helper(components..., std::make_index_sequence<sizeof...(component_types)>{}));
    }
 
    template <typename component_type>
        requires (!std::is_base_of_v<alphabet_tuple_base, component_type>) &&
                 is_unique_component<component_type>
    constexpr explicit alphabet_tuple_base(component_type const alph) noexcept : alphabet_tuple_base{}
    {
        get<component_type>(*this) = alph;
    }
 
    template <typename indirect_component_type>
        requires ((detail::instantiate_if_v<
                    detail::lazy<std::is_convertible, indirect_component_type, component_types>,
                    detail::tuple_general_guard<derived_type, indirect_component_type, component_types...>> || ...))
    constexpr explicit alphabet_tuple_base(indirect_component_type const alph) noexcept : alphabet_tuple_base{}
    {
       using component_type = meta::front<meta::find_if<component_list, detail::implicitly_convertible_from<indirect_component_type>>>;
       component_type tmp(alph); // delegate construction
       get<component_type>(*this) = tmp;
    }
 
    template <typename indirect_component_type>
        requires ((!(detail::instantiate_if_v<
                     detail::lazy<std::is_convertible, indirect_component_type, component_types>,
                     detail::tuple_general_guard<derived_type, indirect_component_type, component_types...>> || ...)) &&
                   (detail::instantiate_if_v<
                     detail::lazy<std::is_constructible, component_types, indirect_component_type>,
                     detail::tuple_general_guard<derived_type, indirect_component_type, component_types...>> || ...))
    constexpr explicit alphabet_tuple_base(indirect_component_type const alph) noexcept : alphabet_tuple_base{}
    {
       using component_type = meta::front<meta::find_if<component_list, detail::constructible_from<indirect_component_type>>>;
       component_type tmp(alph); // delegate construction
       get<component_type>(*this) = tmp;
    }
 
    template <typename component_type>
        requires (!std::derived_from<component_type, alphabet_tuple_base>) &&
                 is_unique_component<component_type>
    constexpr derived_type & operator=(component_type const alph) noexcept
    {
        get<component_type>(*this) = alph;
        return static_cast<derived_type &>(*this);
    }
 
    template <typename indirect_component_type>
        requires ((!std::derived_from<indirect_component_type, alphabet_tuple_base>) &&
                  (!is_unique_component<indirect_component_type>) &&
                  (std::assignable_from<component_types, indirect_component_type> || ...))
    constexpr derived_type & operator=(indirect_component_type const alph) noexcept
    {
        using component_type = meta::front<meta::find_if<component_list, detail::assignable_from<indirect_component_type>>>;
        get<component_type>(*this) = alph; // delegate assignment
        return static_cast<derived_type &>(*this);
    }
    // If not assignable but implicit convertible, convert first and assign afterwards
    template <typename indirect_component_type>
        requires ((!std::derived_from<indirect_component_type, alphabet_tuple_base>) &&
                  (!is_unique_component<indirect_component_type>) &&
                  (!(std::assignable_from<component_types, indirect_component_type> || ...)) &&
                  (std::convertible_to<indirect_component_type, component_types> || ...))
    constexpr derived_type & operator=(indirect_component_type const alph) noexcept
    {
        using component_type = meta::front<meta::find_if<component_list, detail::implicitly_convertible_from<indirect_component_type>>>;
        component_type tmp(alph);
        get<component_type>(*this) = tmp;
        return static_cast<derived_type &>(*this);
    }
 
    template <typename indirect_component_type>
        requires ((!std::derived_from<indirect_component_type, alphabet_tuple_base>) &&
                  (!is_unique_component<indirect_component_type>) &&
                  (!(std::assignable_from<component_types, indirect_component_type> || ...)) &&
                  (!(std::convertible_to<indirect_component_type, component_types> || ...)) &&
                  (std::constructible_from<component_types, indirect_component_type> || ...))
    constexpr derived_type & operator=(indirect_component_type const alph) noexcept
    {
        using component_type = meta::front<meta::find_if<component_list, detail::constructible_from<indirect_component_type>>>;
        component_type tmp(alph); // delegate construction
        get<component_type>(*this) = tmp;
        return static_cast<derived_type &>(*this);
    }
 
    template <size_t index>
    friend constexpr auto get(alphabet_tuple_base & l) noexcept
    {
        static_assert(index < sizeof...(component_types), "Index out of range.");
 
        using t = meta::at_c<component_list, index>;
        t val{};
 
        seqan3::assign_rank_to(l.to_component_rank<index>(), val);
 
        return component_proxy<t, index>{val, l};
    }
 
    template <typename type>
    friend constexpr auto get(alphabet_tuple_base & l) noexcept
        requires is_unique_component<type>
    {
        return get<meta::find_index<component_list, type>::value>(l);
    }
 
    template <size_t index>
    friend constexpr auto get(alphabet_tuple_base const & l) noexcept
    {
        static_assert(index < sizeof...(component_types), "Index out of range.");
 
        using t = meta::at_c<component_list, index>;
 
        return seqan3::assign_rank_to(l.to_component_rank<index>(), t{});
    }
 
    template <typename type>
    friend constexpr type get(alphabet_tuple_base const & l) noexcept
        requires is_unique_component<type>
    {
        return get<meta::find_index<component_list, type>::value>(l);
    }
 
    template <typename type>
    constexpr operator type() const noexcept
        requires is_unique_component<type>
    {
        return get<type>(*this);
    }
 
    template <typename derived_type_t, typename indirect_component_type>
    friend constexpr auto operator==(derived_type_t const lhs, indirect_component_type const rhs) noexcept
        -> std::enable_if_t<detail::tuple_eq_guard<derived_type_t, derived_type, indirect_component_type, component_types...>,
                            bool>
    {
        using component_type = meta::front<meta::find_if<component_list, detail::weakly_equality_comparable_with_<indirect_component_type>>>;
        return get<component_type>(lhs) == rhs;
    }
 
    template <typename derived_type_t, typename indirect_component_type>
    friend constexpr auto operator==(indirect_component_type const lhs, derived_type_t const rhs) noexcept
        -> std::enable_if_t<detail::tuple_eq_guard<derived_type_t, derived_type, indirect_component_type, component_types...>,
                            bool>
    {
        return rhs == lhs;
    }
 
    template <typename derived_type_t, typename indirect_component_type>
    friend constexpr auto operator!=(derived_type_t const lhs, indirect_component_type const rhs) noexcept
        -> std::enable_if_t<detail::tuple_eq_guard<derived_type_t, derived_type, indirect_component_type, component_types...>,
                            bool>
    {
        using component_type = meta::front<meta::find_if<component_list, detail::weakly_equality_comparable_with_<indirect_component_type>>>;
        return get<component_type>(lhs) != rhs;
    }
 
    template <typename derived_type_t, typename indirect_component_type>
    friend constexpr auto operator!=(indirect_component_type const lhs, derived_type_t const rhs) noexcept
        -> std::enable_if_t<detail::tuple_eq_guard<derived_type_t, derived_type, indirect_component_type, component_types...>,
                            bool>
    {
        return rhs != lhs;
    }
 
    template <typename derived_type_t, typename indirect_component_type>
    friend constexpr auto operator<(derived_type_t const lhs, indirect_component_type const rhs) noexcept
        -> std::enable_if_t<detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>,
                            bool>
    {
        using component_type = meta::front<meta::find_if<component_list, detail::weakly_ordered_with_<indirect_component_type>>>;
        return get<component_type>(lhs) < rhs;
    }
 
    template <typename derived_type_t, typename indirect_component_type>
    friend constexpr auto operator<(indirect_component_type const lhs, derived_type_t const rhs) noexcept
        -> std::enable_if_t<detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>,
                            bool>
    {
        return rhs > lhs;
    }
 
    template <typename derived_type_t, typename indirect_component_type>
    friend constexpr auto operator<=(derived_type_t const lhs, indirect_component_type const rhs) noexcept
        -> std::enable_if_t<detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>,
                            bool>
    {
        using component_type = meta::front<meta::find_if<component_list, detail::weakly_ordered_with_<indirect_component_type>>>;
        return get<component_type>(lhs) <= rhs;
    }
 
    template <typename derived_type_t, typename indirect_component_type>
    friend constexpr auto operator<=(indirect_component_type const lhs, derived_type_t const rhs) noexcept
        -> std::enable_if_t<detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>,
                            bool>
    {
        return rhs >= lhs;
    }
 
    template <typename derived_type_t, typename indirect_component_type>
    friend constexpr auto operator>(derived_type_t const lhs, indirect_component_type const rhs) noexcept
          -> std::enable_if_t<detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>,
                            bool>
    {
        using component_type = meta::front<meta::find_if<component_list, detail::weakly_ordered_with_<indirect_component_type>>>;
        return get<component_type>(lhs) > rhs;
    }
 
    template <typename derived_type_t, typename indirect_component_type>
    friend constexpr auto operator>(indirect_component_type const lhs, derived_type_t const rhs) noexcept
        -> std::enable_if_t<detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>,
                            bool>
    {
        return rhs < lhs;
    }
 
    template <typename derived_type_t, typename indirect_component_type>
    friend constexpr auto operator>=(derived_type_t const lhs, indirect_component_type const rhs) noexcept
        -> std::enable_if_t<detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>,
                            bool>
    {
        using component_type = meta::front<meta::find_if<component_list, detail::weakly_ordered_with_<indirect_component_type>>>;
        return get<component_type>(lhs) >= rhs;
    }
 
    template <typename derived_type_t, typename indirect_component_type>
    friend constexpr auto operator>=(indirect_component_type const lhs, derived_type_t const rhs) noexcept
        -> std::enable_if_t<detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>,
                            bool>
    {
        return rhs <= lhs;
    }
 
private:
    template <size_t index>
    constexpr rank_type to_component_rank() const noexcept
    {
        if constexpr (alphabet_size < 1024) // computation is cached for small alphabets
        {
            return rank_to_component_rank[index][to_rank()];
        }
        else
        {
            return (to_rank() / cummulative_alph_sizes[index]) %
                seqan3::alphabet_size<pack_traits::at<index, component_types...>>;
        }
    }
 
    template <size_t index>
    constexpr void assign_component_rank(ptrdiff_t const r) noexcept
    {
        assign_rank(static_cast<ptrdiff_t>(to_rank()) +
                    ((r - static_cast<ptrdiff_t>(to_component_rank<index>())) *
                     static_cast<ptrdiff_t>(cummulative_alph_sizes[index])));
    }
 
    static constexpr std::array<rank_type, component_list::size()> cummulative_alph_sizes
    {
        [] () constexpr
        {
            // create array (1, |sigma1|, |sigma1|*|sigma2|,  ... ,  |sigma1|*...*|sigmaN|)
            std::array<rank_type, component_list::size() + 1> ret{};
            ret[0] = 1;
            size_t count = 1;
            meta::for_each(meta::reverse<component_list>{}, [&] (auto alph) constexpr
            {
                ret[count] = static_cast<rank_type>(seqan3::alphabet_size<decltype(alph)> * ret[count - 1]);
                ++count;
            });
 
            // reverse and strip one: (|sigma1|*...*|sigmaN-1|, ... |sigma1|*|sigma2|, |sigma1|, 1)
            // reverse order guarantees that the first alphabet is the most significant rank contributer
            // resulting in element-wise alphabetical ordering on comparison
            std::array<rank_type, component_list::size()> ret2{};
            for (size_t i = 0; i < component_list::size(); ++i)
                ret2[i] = ret[component_list::size() - i - 1];
 
            return ret2;
        }()
    };
 
    template <std::size_t ...idx>
    static constexpr rank_type rank_sum_helper(component_types ... components, std::index_sequence<idx...> const &) noexcept
    {
        return ((seqan3::to_rank(components) * cummulative_alph_sizes[idx]) + ...);
    }
 
    static constexpr std::array<std::array<rank_type, alphabet_size < 1024 ? alphabet_size : 0>, // not for big alphs
                                list_traits::size<component_list>> rank_to_component_rank
    {
        [] () constexpr
        {
            std::array<std::array<rank_type, alphabet_size < 1024 ? alphabet_size : 0>, // not for big alphs
                       list_traits::size<component_list>> ret{};
 
            if constexpr (alphabet_size < 1024)
            {
                std::array<size_t, alphabet_size> alph_sizes{ seqan3::alphabet_size<component_types>... };
 
                for (size_t i = 0; i < list_traits::size<component_list>; ++i)
                    for (size_t j = 0; j < static_cast<size_t>(alphabet_size); ++j)
                        ret[i][j] = (j / cummulative_alph_sizes[i]) % alph_sizes[i];
            }
 
            return ret;
        }()
    };
};
 
} // namespace seqan3
 
namespace std
{
 
template <std::size_t i, seqan3::detail::alphabet_tuple_base_specialisation tuple_t>
struct tuple_element<i, tuple_t>
{
    using type = meta::at_c<typename tuple_t::seqan3_required_types, i>;
};
 
template <seqan3::detail::alphabet_tuple_base_specialisation tuple_t>
struct tuple_size<tuple_t> :
    public std::integral_constant<size_t, seqan3::list_traits::size<typename tuple_t::seqan3_required_types>>
{};
 
} // namespace std