tuple_base.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2022 deCODE Genetics
// Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2021, 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/biocpp/biocpp-core/blob/main/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <cassert>
#include <concepts>
#include <utility>
 
#include <bio/alphabet/base.hpp>
#include <bio/alphabet/composite/detail.hpp>
#include <bio/alphabet/concept.hpp>
#include <bio/alphabet/proxy_base.hpp>
#include <bio/meta/type_list/function.hpp>
#include <bio/meta/type_list/traits.hpp>
#include <bio/meta/type_list/type_list.hpp>
#include <bio/meta/type_traits/template_inspection.hpp>
 
namespace bio::alphabet::detail
{
 
template <typename tuple_derived_t, typename rhs_t, typename... component_types>
concept tuple_concept_guard = !meta::one_of<rhs_t, tuple_derived_t, component_types...> &&
                              !meta::list_traits::contains<tuple_derived_t, recursive_required_types_t<rhs_t>>;
 
} // namespace bio::alphabet::detail
 
namespace bio::alphabet
{
 
// 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 tuple_base :
  public base<derived_type,
              (1 * ... * size<component_types>),
              void> // no char type, because this is only semi_alphabet
{
private:
    using base_t = base<derived_type,
                        (1 * ... * size<component_types>),
                        void>; // no char type, because this is only semi_alphabet
 
    using component_list = meta::type_list<component_types...>;
 
    template <typename type>
    static constexpr bool is_component = meta::list_traits::contains<type, component_list>;
 
    template <typename type>
    static constexpr bool is_unique_component = (meta::list_traits::count<type, component_list> == 1);
 
    // forward declaration: see implementation below
    template <typename alphabet_type, size_t index>
    class component_proxy;
 
    constexpr tuple_base() noexcept                          = default; 
    constexpr tuple_base(tuple_base const &)                 = default; 
    constexpr tuple_base(tuple_base &&) noexcept             = default; 
    constexpr tuple_base & operator=(tuple_base const &)     = default; 
    constexpr tuple_base & operator=(tuple_base &&) noexcept = default; 
    ~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::assign_rank;
    using base_t::to_rank;
 
    using biocpp_required_types           = component_list;
    using biocpp_recursive_required_types = meta::list_traits::concat<
      component_list,
      meta::transformation_trait_or_t<detail::recursive_required_types<component_types>, meta::type_list<>>...>;
    static constexpr bool biocpp_alphabet_tuple_like = true;
 
    constexpr 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<tuple_base, component_type>) && is_unique_component<component_type>)
    constexpr explicit tuple_base(component_type const alph) noexcept : tuple_base{}
    {
        get<component_type>(*this) = alph;
    }
 
    template <typename indirect_component_type>
        requires(detail::tuple_concept_guard<derived_type, indirect_component_type, component_types...> &&
                 (std::is_convertible_v<indirect_component_type, component_types> || ...))
    constexpr explicit tuple_base(indirect_component_type const alph) noexcept : tuple_base{}
    {
        using component_predicate = detail::implicitly_convertible_from<indirect_component_type>;
        constexpr auto component_position =
          meta::list_traits::find_if<component_predicate::template invoke, component_list>;
        using component_type = meta::list_traits::at<component_position, component_list>;
        component_type tmp(alph); // delegate construction
        get<component_type>(*this) = tmp;
    }
 
    template <typename indirect_component_type>
        requires(detail::tuple_concept_guard<derived_type, indirect_component_type, component_types...> &&
                 (!(std::is_convertible_v<indirect_component_type, component_types> || ...)) &&
                 (std::is_constructible_v<component_types, indirect_component_type> || ...))
    constexpr explicit tuple_base(indirect_component_type const alph) noexcept : tuple_base{}
    {
        using component_predicate = detail::constructible_from<indirect_component_type>;
        constexpr auto component_position =
          meta::list_traits::find_if<component_predicate::template invoke, component_list>;
        using component_type = meta::list_traits::at<component_position, component_list>;
        component_type tmp(alph); // delegate construction
        get<component_type>(*this) = tmp;
    }
 
    template <typename component_type>
        requires((!std::derived_from<component_type, 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, 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_predicate = detail::assignable_from<indirect_component_type>;
        constexpr auto component_position =
          meta::list_traits::find_if<component_predicate::template invoke, component_list>;
        using component_type       = meta::list_traits::at<component_position, component_list>;
        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, 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_predicate = detail::implicitly_convertible_from<indirect_component_type>;
        constexpr auto component_position =
          meta::list_traits::find_if<component_predicate::template invoke, component_list>;
        using component_type = meta::list_traits::at<component_position, component_list>;
        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, 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_predicate = detail::constructible_from<indirect_component_type>;
        constexpr auto component_position =
          meta::list_traits::find_if<component_predicate::template invoke, component_list>;
        using component_type = meta::list_traits::at<component_position, component_list>;
        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(tuple_base & l) noexcept
    {
        static_assert(index < sizeof...(component_types), "Index out of range.");
 
        using t = meta::list_traits::at<index, component_list>;
        t val{};
 
        bio::alphabet::assign_rank_to(l.to_component_rank<index>(), val);
 
        return component_proxy<t, index>{l};
    }
 
    template <typename type>
    friend constexpr auto get(tuple_base & l) noexcept
        requires is_unique_component<type>
    {
        return get<meta::list_traits::find<type, component_list>>(l);
    }
 
    template <size_t index>
    friend constexpr auto get(tuple_base const & l) noexcept
    {
        static_assert(index < sizeof...(component_types), "Index out of range.");
 
        using t = meta::list_traits::at<index, component_list>;
 
        return bio::alphabet::assign_rank_to(l.to_component_rank<index>(), t{});
    }
 
    template <typename type>
    friend constexpr type get(tuple_base const & l) noexcept
        requires is_unique_component<type>
    {
        return get<meta::list_traits::find<type, component_list>>(l);
    }
 
    template <typename type>
    constexpr operator type() const noexcept
        requires is_unique_component<type>
    {
        return get<type>(*this);
    }
 
    template <std::same_as<derived_type> derived_type_t, typename indirect_component_type>
        requires(detail::tuple_concept_guard<derived_type, indirect_component_type, component_types...> &&
                 (meta::weakly_equality_comparable_with<indirect_component_type, component_types> || ...))
    friend constexpr bool operator==(derived_type_t const lhs, indirect_component_type const rhs) noexcept
    {
        using component_predicate = detail::weakly_equality_comparable_with_<indirect_component_type>;
        constexpr auto component_position =
          meta::list_traits::find_if<component_predicate::template invoke, component_list>;
        using component_type = meta::list_traits::at<component_position, component_list>;
        return get<component_type>(lhs) == rhs;
    }
 
    template <std::same_as<derived_type> derived_type_t, typename indirect_component_type>
        requires(detail::tuple_concept_guard<derived_type, indirect_component_type, component_types...> &&
                 (meta::weakly_ordered_with<indirect_component_type, component_types> || ...))
    friend constexpr auto operator<=>(derived_type_t const lhs, indirect_component_type const rhs) noexcept
    {
        using component_predicate = detail::weakly_ordered_with_<indirect_component_type>;
        constexpr auto component_position =
          meta::list_traits::find_if<component_predicate::template invoke, component_list>;
        using component_type = meta::list_traits::at<component_position, component_list>;
        return get<component_type>(lhs) <=> rhs;
    }
 
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]) %
                   bio::alphabet::size<meta::detail::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;
        using reverse_list_t = decltype(meta::list_traits::detail::reverse(component_list{}));
        bio::meta::detail::for_each<reverse_list_t>(
          [&](auto alphabet_type_identity) constexpr
          {
              using alphabet_t = typename decltype(alphabet_type_identity)::type;
              ret[count]       = static_cast<rank_type>(bio::alphabet::size<alphabet_t> * 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 ((bio::alphabet::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
                                             meta::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
                                meta::list_traits::size<component_list>>
                       ret{};
 
        if constexpr (alphabet_size < 1024)
        {
            std::array<size_t, alphabet_size> alph_sizes{bio::alphabet::size<component_types>...};
 
            for (size_t i = 0; i < meta::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;
    }();
};
 
template <typename derived_type, typename... component_types>
    requires((detail::writable_constexpr_semialphabet<component_types> && ...) &&
             (std::regular<component_types> && ...))
template <typename alphabet_type, size_t index>
class tuple_base<derived_type, component_types...>::component_proxy :
  public proxy_base<component_proxy<alphabet_type, index>, alphabet_type>
{
private:
    using base_t = proxy_base<component_proxy<alphabet_type, index>, alphabet_type>;
    friend base_t;
 
    tuple_base * parent;
 
public:
    //Import from base type:
    using base_t::operator=;
 
    component_proxy()                                           = delete;
    constexpr component_proxy(component_proxy const &) noexcept = default; 
    constexpr component_proxy(component_proxy &&) noexcept      = default; 
    ~component_proxy() noexcept                                 = default; 
 
    constexpr component_proxy(tuple_base & p) : parent{&p} {}
 
    constexpr component_proxy & operator=(component_proxy const & rhs) // NOLINT(bugprone-unhandled-self-assignment)
    {
        return assign_rank(rhs.to_rank());
    }
 
    // NOLINTNEXTLINE(bugprone-unhandled-self-assignment)
    constexpr component_proxy const & operator=(component_proxy const & rhs) const
    {
        return assign_rank(rhs.to_rank());
    }
 
    constexpr alphabet::rank_t<alphabet_type> to_rank() const noexcept { return parent->to_component_rank<index>(); }
 
    constexpr component_proxy & assign_rank(alphabet::rank_t<alphabet_type> const r) noexcept
    {
        parent->assign_component_rank<index>(r);
        return *this;
    }
 
    constexpr component_proxy const & assign_rank(alphabet::rank_t<alphabet_type> const r) const noexcept
    {
        parent->assign_component_rank<index>(r);
        return *this;
    }
 
    friend constexpr bool operator==(derived_type const lhs, component_proxy const rhs) noexcept
    {
        return get<index>(lhs) == static_cast<alphabet_type>(rhs);
    }
 
    friend constexpr auto operator<=>(derived_type const lhs, component_proxy const rhs) noexcept
    {
        return get<index>(lhs) <=> static_cast<alphabet_type>(rhs);
    }
};
 
} // namespace bio::alphabet
 
namespace std
{
 
template <std::size_t i, bio::alphabet::detail::alphabet_tuple_like tuple_t>
struct tuple_element<i, tuple_t>
{
    using type = bio::meta::list_traits::at<i, typename tuple_t::biocpp_required_types>;
};
 
template <bio::alphabet::detail::alphabet_tuple_like tuple_t>
struct tuple_size<tuple_t> :
  public std::integral_constant<size_t, bio::meta::list_traits::size<typename tuple_t::biocpp_required_types>>
{};
 
} // namespace std