concept.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 <seqan3/std/type_traits>
 
#include <seqan3/alphabet/exception.hpp>
#include <seqan3/core/concept/cereal.hpp>
#include <seqan3/core/detail/customisation_point.hpp>
#include <seqan3/utility/detail/exposition_only_concept.hpp>
#include <seqan3/utility/detail/type_name_as_string.hpp>
#include <seqan3/utility/type_traits/basic.hpp>
 
// ============================================================================
// forwards
// ============================================================================
 
namespace seqan3::custom
{
 
template <typename t>
struct alphabet
{};
 
template <typename t>
struct alphabet<t const> : alphabet<t>
{};
 
template <typename t>
struct alphabet<t &> : alphabet<t>
{};
 
template <typename t>
struct alphabet<t const &> : alphabet<t>
{};
 
} // namespace seqan3::custom
 
// ============================================================================
// to_rank()
// ============================================================================
 
namespace seqan3::detail::adl_only
{
 
template <typename ...args_t>
void to_rank(args_t ...) = delete;
 
struct to_rank_fn
{
public:
    SEQAN3_CPO_IMPL(2, seqan3::custom::alphabet<decltype(v)>::to_rank(v))    // explicit customisation
    SEQAN3_CPO_IMPL(1, to_rank(v)                                       )    // ADL
    SEQAN3_CPO_IMPL(0, v.to_rank()                                      )    // member
 
public:
    template <typename alph_t>
        requires requires (alph_t const a)
        {
            { impl(priority_tag<2>{}, a) };
            requires noexcept(impl(priority_tag<2>{}, a));
            requires std::integral<decltype(impl(priority_tag<2>{}, a))>;
        }
    constexpr auto operator()(alph_t const a) const noexcept
    {
        return impl(priority_tag<2>{}, a);
    }
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
inline constexpr auto to_rank = detail::adl_only::to_rank_fn{};
 
template <typename semi_alphabet_type>
    requires requires { { seqan3::to_rank(std::declval<semi_alphabet_type>()) }; }
using alphabet_rank_t = decltype(seqan3::to_rank(std::declval<semi_alphabet_type>()));
 
} // namespace seqan3
 
// ============================================================================
// assign_rank_to()
// ============================================================================
 
namespace seqan3::detail::adl_only
{
 
template <typename ...args_t>
void assign_rank_to(args_t ...) = delete;
 
struct assign_rank_to_fn
{
public:
    SEQAN3_CPO_IMPL(2, (seqan3::custom::alphabet<decltype(v)>::assign_rank_to(args..., v))) // explicit customisation
    SEQAN3_CPO_IMPL(1, (assign_rank_to(args..., v)                                       )) // ADL
    SEQAN3_CPO_IMPL(0, (v.assign_rank(args...)                                           )) // member
 
public:
    template <typename alph_t>
        requires requires (seqan3::alphabet_rank_t<alph_t> const r, alph_t & a)
            {
                { impl(priority_tag<2>{}, a, r) };
                requires noexcept(impl(priority_tag<2>{}, a, r));
                requires std::same_as<alph_t &, decltype(impl(priority_tag<2>{}, a, r))>;
            }
    constexpr alph_t operator()(seqan3::alphabet_rank_t<alph_t> const r, alph_t && a) const noexcept
    {
        return impl(priority_tag<2>{}, a, r);
    }
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
inline constexpr auto assign_rank_to = detail::adl_only::assign_rank_to_fn{};
} // namespace seqan3
 
// ============================================================================
// to_char()
// ============================================================================
 
namespace seqan3::detail::adl_only
{
 
template <typename ...args_t>
void to_char(args_t ...) = delete;
 
struct to_char_cpo : public detail::customisation_point_object<to_char_cpo, 2>
{
    using base_t = detail::customisation_point_object<to_char_cpo, 2>;
    using base_t::base_t;
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<2>, alphabet_t && alphabet)
    (
        /*return*/ seqan3::custom::alphabet<alphabet_t>::to_char(std::forward<alphabet_t>(alphabet)) /*;*/
    );
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<1>, alphabet_t && alphabet)
    (
        /*return*/ to_char(std::forward<alphabet_t>(alphabet)) /*;*/
    );
 
    template <typename alphabet_t>
    static constexpr auto SEQAN3_CPO_OVERLOAD(priority_tag<0>, alphabet_t && alphabet)
    (
        /*return*/ std::forward<alphabet_t>(alphabet).to_char() /*;*/
    );
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
inline constexpr auto to_char = detail::adl_only::to_char_cpo{};
 
template <typename alphabet_type>
    requires requires (alphabet_type const a) { { seqan3::to_char(a) }; }
using alphabet_char_t = decltype(seqan3::to_char(std::declval<alphabet_type const>()));
 
} // namespace seqan3
 
// ============================================================================
// assign_char_to()
// ============================================================================
 
namespace seqan3::detail::adl_only
{
 
template <typename ...args_t>
void assign_char_to(args_t ...) = delete;
 
struct assign_char_to_fn
{
public:
    SEQAN3_CPO_IMPL(2, (seqan3::custom::alphabet<decltype(v)>::assign_char_to(args..., v))) // explicit customisation
    SEQAN3_CPO_IMPL(1, (assign_char_to(args..., v)                                       )) // ADL
    SEQAN3_CPO_IMPL(0, (v.assign_char(args...)                                           )) // member
 
public:
    template <typename alph_t>
        requires requires (seqan3::alphabet_char_t<alph_t> const r, alph_t & a)
            {
                { impl(priority_tag<2>{}, a, r) };
                requires noexcept(impl(priority_tag<2>{}, a, r));
                requires std::same_as<alph_t &, decltype(impl(priority_tag<2>{}, a, r))>;
            }
    constexpr alph_t operator()(seqan3::alphabet_char_t<alph_t> const r, alph_t && a) const noexcept
    {
        return impl(priority_tag<2>{}, a, r);
    }
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
inline constexpr auto assign_char_to = detail::adl_only::assign_char_to_fn{};
} // namespace seqan3
 
// ============================================================================
// char_is_valid_for()
// ============================================================================
 
namespace seqan3::detail::adl_only
{
 
template <typename ...args_t>
void char_is_valid_for(args_t ...) = delete;
 
template <typename alph_t>
struct char_is_valid_for_fn
{
public:
    using s_alph_t = std::conditional_t<std::is_nothrow_default_constructible_v<std::remove_cvref_t<alph_t>>,
                                        std::remove_cvref_t<alph_t>,
                                        std::type_identity<alph_t>>;
 
    SEQAN3_CPO_IMPL(3, (deferred_type_t<seqan3::custom::alphabet<alph_t>, decltype(v)>::char_is_valid(v))) // expl. cst.
    SEQAN3_CPO_IMPL(2, (char_is_valid_for(v, s_alph_t{})                                                )) // ADL
    SEQAN3_CPO_IMPL(1, (deferred_type_t<std::remove_cvref_t<alph_t>, decltype(v)>::char_is_valid(v)          )) // member
    SEQAN3_CPO_IMPL(0, (seqan3::to_char(seqan3::assign_char_to(v, s_alph_t{})) == v                     )) // fallback
 
public:
    template <typename dummy = int> // need to make this a template to enforce deferred instantiation
        requires requires (alphabet_char_t<alph_t> const a)
        {
            { impl(priority_tag<3>{}, a, dummy{}) };
            requires noexcept(impl(priority_tag<3>{}, a, dummy{}));
            SEQAN3_RETURN_TYPE_CONSTRAINT(impl(priority_tag<3>{}, a, dummy{}), std::convertible_to, bool);
        }
    constexpr bool operator()(alphabet_char_t<alph_t> const a) const noexcept
    {
        return impl(priority_tag<3>{}, a);
    }
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
template <typename alph_t>
    requires requires { { to_char(std::declval<alph_t>()) }; } // to_char() is required by some defs
inline constexpr auto char_is_valid_for = detail::adl_only::char_is_valid_for_fn<alph_t>{};
} // namespace seqan3
 
// ============================================================================
// assign_char_strictly_to()
// ============================================================================
 
namespace seqan3::detail::adl_only
{
 
struct assign_char_strictly_to_fn
{
    template <typename alphabet_t>
    constexpr decltype(auto) operator()(seqan3::alphabet_char_t<alphabet_t> const chr, alphabet_t && alphabet) const
        requires requires ()
        {
            SEQAN3_RETURN_TYPE_CONSTRAINT(seqan3::assign_char_to(chr, std::forward<alphabet_t>(alphabet)),
                                          std::convertible_to, alphabet_t);
            SEQAN3_RETURN_TYPE_CONSTRAINT(seqan3::char_is_valid_for<alphabet_t>(chr), std::same_as, bool);
        }
    {
        if (!seqan3::char_is_valid_for<alphabet_t>(chr))
            throw seqan3::invalid_char_assignment{detail::type_name_as_string<alphabet_t>, chr};
 
        return seqan3::assign_char_to(chr, std::forward<alphabet_t>(alphabet));
    }
};
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
inline constexpr auto assign_char_strictly_to = detail::adl_only::assign_char_strictly_to_fn{};
} // namespace seqan3
 
// ============================================================================
// alphabet_size
// ============================================================================
 
namespace seqan3::detail::adl_only
{
 
template <typename ...args_t>
void alphabet_size(args_t ...) = delete;
 
template <typename alph_t>
struct alphabet_size_fn
{
public:
    using s_alph_t = std::conditional_t<std::is_nothrow_default_constructible_v<std::remove_cvref_t<alph_t>> &&
                                        seqan3::is_constexpr_default_constructible_v<std::remove_cvref_t<alph_t>>,
                                        std::remove_cvref_t<alph_t>,
                                        std::type_identity<alph_t>>;
 
    SEQAN3_CPO_IMPL(2, (deferred_type_t<seqan3::custom::alphabet<alph_t>, decltype(v)>::alphabet_size)) // expl. cst.
    SEQAN3_CPO_IMPL(1, (alphabet_size(v)                                                             )) // ADL
    SEQAN3_CPO_IMPL(0, (deferred_type_t<std::remove_cvref_t<alph_t>, decltype(v)>::alphabet_size          )) // member
 
public:
    template <typename dummy = int> // need to make this a template to enforce deferred instantiation
        requires requires
        {
            { impl(priority_tag<2>{}, s_alph_t{}, dummy{}) };
            requires noexcept(impl(priority_tag<2>{}, s_alph_t{}, dummy{}));
            requires std::integral<std::remove_cvref_t<decltype(impl(priority_tag<2>{}, s_alph_t{}, dummy{}))>>;
        }
    constexpr auto operator()() const noexcept
    {
        // The following cannot be added to the list of constraints, because it is not properly deferred
        // for incomplete types which leads to breakage.
        static_assert(SEQAN3_IS_CONSTEXPR(impl(priority_tag<2>{}, s_alph_t{})),
            "Only overloads that are marked constexpr are picked up by seqan3::alphabet_size.");
        return impl(priority_tag<2>{}, s_alph_t{});
    }
};
 
#if SEQAN3_WORKAROUND_GCC_89953
template <typename alph_t>
    requires requires { { alphabet_size_fn<alph_t>{} }; }
inline constexpr auto alphabet_size_obj = alphabet_size_fn<alph_t>{};
#endif // SEQAN3_WORKAROUND_GCC_89953
 
} // namespace seqan3::detail::adl_only
 
namespace seqan3
{
 
#if SEQAN3_WORKAROUND_GCC_89953
template <typename alph_t>
    requires requires { { detail::adl_only::alphabet_size_fn<alph_t>{} }; } &&
             requires { { detail::adl_only::alphabet_size_obj<alph_t>() }; } // ICE workarounds
inline constexpr auto alphabet_size = detail::adl_only::alphabet_size_obj<alph_t>();
#else // ^^^ workaround / no workaround vvv
template <typename alph_t>
    requires requires { { detail::adl_only::alphabet_size_fn<alph_t>{}() }; }
inline constexpr auto alphabet_size = detail::adl_only::alphabet_size_fn<alph_t>{}();
#endif // SEQAN3_WORKAROUND_GCC_89953
 
// ============================================================================
// semialphabet
// ============================================================================
 
template <typename t>
SEQAN3_CONCEPT semialphabet =
    std::totally_ordered<t> &&
    std::copy_constructible<t> &&
    std::is_nothrow_copy_constructible_v<t> &&
    requires (t v)
{
    { seqan3::alphabet_size<t> };
    { seqan3::to_rank(v) };
};
 
// ============================================================================
// writable_semialphabet
// ============================================================================
 
template <typename t>
SEQAN3_CONCEPT writable_semialphabet = semialphabet<t> && requires (t v, alphabet_rank_t<t> r)
{
    { seqan3::assign_rank_to(r, v) };
};
 
// ============================================================================
// alphabet
// ============================================================================
 
template <typename t>
SEQAN3_CONCEPT alphabet = semialphabet<t> && requires (t v)
{
    { seqan3::to_char(v) };
};
 
// ============================================================================
// writable_alphabet
// ============================================================================
 
template <typename t>
SEQAN3_CONCEPT writable_alphabet = alphabet<t> && writable_semialphabet<t> && requires (t v, alphabet_char_t<t> c)
{
    { seqan3::assign_char_to(c, v) };
};
 
// ============================================================================
//  serialisation
// ============================================================================
 
template <cereal_output_archive archive_t, semialphabet alphabet_t>
alphabet_rank_t<alphabet_t> CEREAL_SAVE_MINIMAL_FUNCTION_NAME(archive_t const &, alphabet_t const & l)
{
    return to_rank(l);
}
 
template <cereal_input_archive archive_t, typename wrapped_alphabet_t>
void CEREAL_LOAD_MINIMAL_FUNCTION_NAME(archive_t const &,
                                       wrapped_alphabet_t && l,
                                       alphabet_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 seqan3
 
namespace seqan3::detail
{
// ============================================================================
// constexpr_semialphabet
// ============================================================================
 
template <typename t>
SEQAN3_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 SEQAN3_IS_CONSTEXPR(to_rank(std::remove_reference_t<t>{}));
};
 
// ============================================================================
// writable_constexpr_semialphabet
// ============================================================================
 
template <typename t>
SEQAN3_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
    requires SEQAN3_IS_CONSTEXPR(seqan3::assign_rank_to(alphabet_rank_t<t>{}, std::remove_reference_t<t>{}));
};
 
// ============================================================================
// constexpr_alphabet
// ============================================================================
 
template <typename t>
SEQAN3_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 SEQAN3_IS_CONSTEXPR(to_char(std::remove_reference_t<t>{}));
};
 
// ============================================================================
// writable_constexpr_alphabet
// ============================================================================
 
template <typename t>
SEQAN3_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
    requires SEQAN3_IS_CONSTEXPR(seqan3::assign_char_to(alphabet_char_t<t>{}, std::remove_reference_t<t>{}));
};
 
} // namespace seqan3::detail