concept.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2022 deCODE Genetics
// 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/biocpp/biocpp-core/blob/main/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <type_traits>
 
#include <bio/alphabet/custom/tag.hpp>
#include <bio/alphabet/exception.hpp>
#include <bio/core.hpp>
#include <bio/meta/concept/core_language.hpp>
#include <bio/meta/detail/type_inspection.hpp>
#include <bio/meta/tag/priority_tag.hpp>
#include <bio/meta/type_traits/basic.hpp>
 
// ============================================================================
// to_rank()
// ============================================================================
 
namespace bio::alphabet
{
 
inline constexpr auto to_rank = []<typename alph_t>(alph_t const a) noexcept
    requires(requires {
        {
            tag_invoke(custom::to_rank{}, a)
        } -> std::integral;
        requires noexcept(tag_invoke(custom::to_rank{}, a));
    })
{
    return tag_invoke(custom::to_rank{}, a);
};
 
template <typename semi_alphabet_type>
    requires(requires {
                {
                    bio::alphabet::to_rank(std::declval<semi_alphabet_type>())
                };
            })
using rank_t = decltype(bio::alphabet::to_rank(std::declval<semi_alphabet_type>()));
 
// ============================================================================
// assign_rank_to()
// ============================================================================
 
inline constexpr auto assign_rank_to =
  []<typename alph_t>(bio::alphabet::rank_t<alph_t> const r, alph_t && a) noexcept -> alph_t
    requires(requires {
        {
            tag_invoke(custom::assign_rank_to{}, r, a)
        } -> std::same_as<alph_t &>;
        requires noexcept(tag_invoke(custom::assign_rank_to{}, r, a));
    })
{
    return tag_invoke(custom::assign_rank_to{}, r, a);
};
 
// ============================================================================
// to_char()
// ============================================================================
 
inline constexpr auto to_char = []<typename alph_t>(alph_t const a) noexcept
    requires(requires {
        {
            tag_invoke(custom::to_char{}, a)
        } -> std::integral;
        requires noexcept(tag_invoke(custom::to_char{}, a));
    })
{
    return tag_invoke(custom::to_char{}, a);
};
 
template <typename alphabet_type>
    requires(requires(alphabet_type const a) {
                {
                    bio::alphabet::to_char(a)
                };
            })
using char_t = decltype(bio::alphabet::to_char(std::declval<alphabet_type const>()));
 
// ============================================================================
// assign_char_to()
// ============================================================================
 
inline constexpr auto assign_char_to =
  []<typename alph_t>(bio::alphabet::char_t<alph_t> const c, alph_t && a) noexcept -> alph_t
    requires(requires {
        {
            tag_invoke(custom::assign_char_to{}, c, a)
        } -> std::same_as<alph_t &>;
        requires noexcept(tag_invoke(custom::assign_char_to{}, c, a));
    })
{
    return tag_invoke(custom::assign_char_to{}, c, a);
};
} // namespace bio::alphabet
 
// ============================================================================
// char_is_valid_for()
// ============================================================================
 
namespace bio::alphabet::detail
{
 
template <typename alph_t>
struct char_is_valid_for_fn
{
    template <typename alph2_t>
    static constexpr bool impl(char_t<alph2_t> const chr, meta::priority_tag<0>) noexcept
        requires std::is_nothrow_default_constructible_v<alph2_t>
    {
        return to_char(assign_char_to(chr, alph2_t{})) == chr;
    }
 
    template <typename alph2_t, typename wrap_t = meta::default_initialisable_wrap_t<alph2_t>>
        requires(requires(char_t<alph2_t> const c) {
            {
                tag_invoke(std::declval<custom::char_is_valid_for>(), c, wrap_t{})
            } -> std::same_as<bool>;
            requires noexcept(tag_invoke(std::declval<custom::char_is_valid_for>(), c, wrap_t{}));
        })
    static constexpr bool impl(char_t<alph2_t> const chr, meta::priority_tag<1>) noexcept
    {
        return tag_invoke(custom::char_is_valid_for{}, chr, wrap_t{});
    }
 
    constexpr auto operator()(char_t<alph_t> const chr) const noexcept
      -> decltype(impl<std::remove_cvref_t<alph_t>>(chr, meta::priority_tag<1>{}))
    {
        return impl<std::remove_cvref_t<alph_t>>(chr, meta::priority_tag<1>{});
    }
};
 
} // namespace bio::alphabet::detail
 
namespace bio::alphabet
{
 
template <typename alph_t>
    requires(requires(char_t<alph_t> a) {
                {
                    detail::char_is_valid_for_fn<alph_t>{}(a)
                };
            })
inline constexpr auto char_is_valid_for = detail::char_is_valid_for_fn<alph_t>{};
 
 
} // namespace bio::alphabet
 
// ============================================================================
// assign_char_strictly_to()
// ============================================================================
 
namespace bio::alphabet::detail
{
 
struct assign_char_strictly_to_fn
{
    template <typename alph_t>
        requires(requires(alph_t a, bio::alphabet::char_t<alph_t> r) {
            {
                bio::alphabet::assign_char_to(r, a)
            };
            {
                bio::alphabet::char_is_valid_for<alph_t>(r)
            };
        })
    auto operator()(bio::alphabet::char_t<alph_t> const r, alph_t && a) const -> alph_t
    {
        if (!bio::alphabet::char_is_valid_for<alph_t>(r))
            throw bio::alphabet::invalid_char_assignment{meta::detail::type_name_as_string<alph_t>, r};
 
        return bio::alphabet::assign_char_to(r, a);
    }
};
 
} // namespace bio::alphabet::detail
 
namespace bio::alphabet
{
 
inline constexpr auto assign_char_strictly_to = detail::assign_char_strictly_to_fn{};
 
// ============================================================================
// size
// ============================================================================
 
template <typename alph_t, typename wrap_t = meta::default_initialisable_wrap_t<alph_t>>
    requires(requires {
                {
                    tag_invoke(custom::size{}, wrap_t{})
                } -> std::integral;
                requires BIOCPP_IS_CONSTEXPR(tag_invoke(custom::size{}, wrap_t{}));
            })
inline constexpr auto size = tag_invoke(custom::size{}, wrap_t{});
 
// ============================================================================
// semialphabet
// ============================================================================
 
template <typename t>
concept semialphabet =
  std::totally_ordered<t> && std::copy_constructible<t> && std::is_nothrow_copy_constructible_v<t> && requires(t v) {
      {
          bio::alphabet::size<t>
      };
      {
          bio::alphabet::to_rank(v)
      };
  };
 
// ============================================================================
// writable_semialphabet
// ============================================================================
 
template <typename t>
concept writable_semialphabet = semialphabet<t> && requires(t v, rank_t<t> r) {
    {
        bio::alphabet::assign_rank_to(r, v)
    };
};
 
// ============================================================================
// alphabet
// ============================================================================
 
template <typename t>
concept alphabet = semialphabet<t> && requires(t v) {
    {
        bio::alphabet::to_char(v)
    };
};
 
// ============================================================================
// writable_alphabet
// ============================================================================
 
template <typename t>
concept writable_alphabet = alphabet<t> && writable_semialphabet<t> && requires(t v, char_t<t> c) {
    {
        bio::alphabet::assign_char_to(c, v)
    };
 
    {
        bio::alphabet::char_is_valid_for<t>(c)
    };
};
 
} // namespace bio::alphabet
// ============================================================================
//  serialisation
// ============================================================================
 
#if __has_include(<cereal/details/traits.hpp>)
#    include <cereal/details/traits.hpp>
#endif
 
namespace bio::alphabet::detail
{
 
#if __has_include(<cereal/details/traits.hpp>)
template <typename type>
using strip_cereal_wrapper_t = typename cereal::traits::strip_minimal<std::decay_t<type>>::type;
#else
template <typename type>
using strip_cereal_wrapper_t = type;
#endif
 
} // namespace bio::alphabet::detail
 
namespace bio::alphabet
{
 
template <typename archive_t, semialphabet alphabet_t>
rank_t<alphabet_t> save_minimal(archive_t const &, alphabet_t const & l)
{
    return to_rank(l);
}
 
template <typename archive_t, typename wrapped_alphabet_t>
void load_minimal(archive_t const &,
                  wrapped_alphabet_t &&                                              l,
                  rank_t<detail::strip_cereal_wrapper_t<wrapped_alphabet_t>> const & r)
    requires semialphabet<detail::strip_cereal_wrapper_t<wrapped_alphabet_t>>
{
    assign_rank_to(r, static_cast<detail::strip_cereal_wrapper_t<wrapped_alphabet_t> &>(l));
}
} // namespace bio::alphabet
 
namespace bio::alphabet::detail
{
// ============================================================================
// constexpr_semialphabet
// ============================================================================
 
template <typename t>
concept constexpr_semialphabet = semialphabet<t> && requires {
    // currently only tests rvalue interfaces, because we have no constexpr values in this scope to get references to
    requires BIOCPP_IS_CONSTEXPR(to_rank(std::remove_reference_t<t>{}));
};
 
// ============================================================================
// writable_constexpr_semialphabet
// ============================================================================
 
template <typename t>
concept writable_constexpr_semialphabet = constexpr_semialphabet<t> && writable_semialphabet<t> && requires {
// currently only tests rvalue interfaces, because we have no constexpr values in this scope to get references to
#if BIOCPP_WORKAROUND_CLANG_58078
    requires true;
#else
    requires BIOCPP_IS_CONSTEXPR(bio::alphabet::assign_rank_to(rank_t<t>{}, std::remove_reference_t<t>{}));
#endif
};
 
// ============================================================================
// constexpr_alphabet
// ============================================================================
 
template <typename t>
concept constexpr_alphabet = constexpr_semialphabet<t> && alphabet<t> && requires {
    // currently only tests rvalue interfaces, because we have no constexpr values in this scope to get references to
    requires BIOCPP_IS_CONSTEXPR(to_char(std::remove_reference_t<t>{}));
};
 
// ============================================================================
// writable_constexpr_alphabet
// ============================================================================
 
template <typename t>
concept writable_constexpr_alphabet =
  constexpr_alphabet<t> && writable_constexpr_semialphabet<t> && writable_alphabet<t> && requires {
// currently only tests rvalue interfaces, because we have no constexpr values in this scope to get references to
#if !BIOCPP_WORKAROUND_CLANG_58078
      requires BIOCPP_IS_CONSTEXPR(bio::alphabet::assign_char_to(char_t<t>{}, std::remove_reference_t<t>{}));
#endif
      requires BIOCPP_IS_CONSTEXPR(bio::alphabet::char_is_valid_for<t>(char_t<t>{}));
  };
 
} // namespace bio::alphabet::detail