concept.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, 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 <iostream>

#include <seqan3/alphabet/adaptation/char.hpp>
#include <seqan3/alphabet/adaptation/uint.hpp>
#include <seqan3/alphabet/exception.hpp>
#include <seqan3/core/concept/cereal.hpp>
#include <seqan3/core/concept/core_language.hpp>
#include <seqan3/core/detail/customisation_point.hpp>
#include <seqan3/core/detail/reflection.hpp>
#include <seqan3/core/type_traits/basic.hpp>
#include <seqan3/core/type_traits/function.hpp>
#include <seqan3/std/concepts>

// ============================================================================
// to_rank()
// ============================================================================

namespace seqan3::detail::adl::only
{

struct to_rank_fn
{
private:
    SEQAN3_CPO_IMPL(2, to_rank(v)                       )    // ADL
    SEQAN3_CPO_IMPL(1, seqan3::custom::to_rank(v)       )    // customisation namespace
    SEQAN3_CPO_IMPL(0, v.to_rank()                      )    // member

public:
    template <typename alph_t>
        requires requires (alph_t const a) { { impl(priority_tag<2>{}, a) }; }
    constexpr auto operator()(alph_t const a) const noexcept
    {
        static_assert(noexcept(impl(priority_tag<2>{}, a)),
            "Only overloads that are marked noexcept are picked up by seqan3::to_rank().");
        static_assert(std::Constructible<size_t, decltype(impl(priority_tag<2>{}, a))>,
            "The return type of your to_rank() implementation must be convertible to size_t.");

        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
{

struct assign_rank_to_fn
{
private:
    SEQAN3_CPO_IMPL(2, (assign_rank_to(args..., v)                           ))    // ADL
    SEQAN3_CPO_IMPL(1, (seqan3::custom::assign_rank_to(args..., v)           ))    // customisation namespace
    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) }; }
    constexpr alph_t & operator()(seqan3::alphabet_rank_t<alph_t> const r, alph_t & a) const noexcept
    {
        static_assert(noexcept(impl(priority_tag<2>{}, a, r)),
            "Only overloads that are marked noexcept are picked up by seqan3::assign_rank_to().");
        static_assert(std::Same<alph_t &, decltype(impl(priority_tag<2>{}, a, r))>,
            "The return type of your assign_rank_to() implementation must be 'alph_t &'.");

        return impl(priority_tag<2>{}, a, r);
    }

    template <typename alph_t>
        requires requires (seqan3::alphabet_rank_t<alph_t> const r, alph_t & a)
            { { impl(priority_tag<2>{}, a, r) }; } && (!std::is_lvalue_reference_v<alph_t>)
    constexpr alph_t operator()(seqan3::alphabet_rank_t<alph_t> const r, alph_t && a) const noexcept
    {
        return (*this)(r, a); // call above function but return by value
    }
};

} // 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
{

struct to_char_fn
{
private:
    SEQAN3_CPO_IMPL(2, to_char(v)                       )    // ADL
    SEQAN3_CPO_IMPL(1, seqan3::custom::to_char(v)       )    // customisation namespace
    SEQAN3_CPO_IMPL(0, v.to_char()                      )    // member

public:
    template <typename alph_t>
        requires requires (alph_t const a) { { impl(priority_tag<2>{}, a) }; }
    constexpr decltype(auto) operator()(alph_t const a) const noexcept
    {
        static_assert(noexcept(impl(priority_tag<2>{}, a)),
            "Only overloads that are marked noexcept are picked up by seqan3::to_char().");

        return impl(priority_tag<2>{}, a);
    }
};

} // namespace seqan3::detail::adl::only

namespace seqan3
{

inline constexpr auto to_char = detail::adl::only::to_char_fn{};

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::custom
{
void char_is_valid_for(); // forward
} // seqan3::custom

namespace seqan3::detail::adl::only
{
struct assign_char_to_fn
{
private:
    SEQAN3_CPO_IMPL(2, (assign_char_to(args..., v)                           ))    // ADL
    SEQAN3_CPO_IMPL(1, (seqan3::custom::assign_char_to(args..., v)           ))    // customisation namespace
    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) }; }
    constexpr alph_t & operator()(seqan3::alphabet_char_t<alph_t> const r, alph_t & a) const noexcept
    {
        static_assert(noexcept(impl(priority_tag<2>{}, a, r)),
            "Only overloads that are marked noexcept are picked up by seqan3::assign_char_to().");
        static_assert(std::Same<alph_t &, decltype(impl(priority_tag<2>{}, a, r))>,
            "The return type of your assign_char_to() implementation must be 'alph_t &'.");

        return impl(priority_tag<2>{}, a, r);
    }

    template <typename alph_t>
        requires requires (seqan3::alphabet_char_t<alph_t> const r, alph_t & a)
            { { impl(priority_tag<2>{}, a, r) }; } && (!std::is_lvalue_reference_v<alph_t>)
    constexpr alph_t operator()(seqan3::alphabet_char_t<alph_t> const r, alph_t && a) const noexcept
    {
        return (*this)(r, a); // call above function but return by value
    }
};

} // 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::custom
{
void char_is_valid_for(); // forward
} // seqan3::custom

namespace seqan3::detail::adl::only
{
template <typename alph_t,
          typename s_alph_t = std::conditional_t<std::is_nothrow_default_constructible_v<remove_cvref_t<alph_t>>,
                                                 remove_cvref_t<alph_t>,
                                                 std::type_identity<alph_t>>>
struct char_is_valid_for_fn
{
private:
    SEQAN3_CPO_IMPL(3, (char_is_valid_for(v, s_alph_t{})                                       ))    // ADL
    SEQAN3_CPO_IMPL(2, (seqan3::custom::char_is_valid_for(v, s_alph_t{})                       ))    // customisation ns
    SEQAN3_CPO_IMPL(1, (deferred_type_t<remove_cvref_t<alph_t>, decltype(v)>::char_is_valid(v) ))    // member
    SEQAN3_CPO_IMPL(0, (to_char(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{}) }; }
    constexpr bool operator()(alphabet_char_t<alph_t> const a) const noexcept
    {
        static_assert(noexcept(impl(priority_tag<3>{}, a)),
            "Only overloads that are marked noexcept are picked up by seqan3::char_is_valid_for().");
        static_assert(std::Same<bool, decltype(impl(priority_tag<3>{}, a))>,
            "The return type of your char_is_valid_for() implementation must be 'bool'.");

        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 alph_t>
        requires requires (alph_t a, seqan3::alphabet_char_t<alph_t> r)
        {
            { seqan3::assign_char_to(r, a) } -> alph_t;
            { seqan3::char_is_valid_for<alph_t>(r) } -> bool;
        }
    decltype(auto) operator()(seqan3::alphabet_char_t<alph_t> const r, alph_t & a) const
    {
        if (!seqan3::char_is_valid_for<alph_t>(r))
            throw seqan3::invalid_char_assignment{seqan3::detail::get_display_name_v<alph_t>, r};

        return seqan3::assign_char_to(r, a);
    }

    template <typename alph_t>
        requires requires (alph_t a, seqan3::alphabet_char_t<alph_t> r)
        {
            { seqan3::assign_char_to(r, a) } -> alph_t;
            { seqan3::char_is_valid_for<alph_t>(r) } -> bool;
        }
    auto operator()(seqan3::alphabet_char_t<alph_t> const r, alph_t && a) const
    {
        return operator()(r, a); // call above function but return by value
    }
};

} // 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 alph_t,
          typename s_alph_t = std::conditional_t<std::is_nothrow_default_constructible_v<remove_cvref_t<alph_t>> &&
                                                 seqan3::is_constexpr_default_constructible_v<remove_cvref_t<alph_t>>,
                                                 remove_cvref_t<alph_t>,
                                                 std::type_identity<alph_t>>>
struct alphabet_size_fn
{
private:
    SEQAN3_CPO_IMPL(2, (alphabet_size(v)                           ))    // ADL
    SEQAN3_CPO_IMPL(1, (seqan3::custom::alphabet_size(v)           ))    // customisation namespace
    SEQAN3_CPO_IMPL(0, (deferred_type_t<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{}) }; }
    constexpr auto operator()() const noexcept
    {
        static_assert(noexcept(impl(priority_tag<2>{}, s_alph_t{})),
            "Only overloads that are marked noexcept are picked up by seqan3::alphabet_size.");
        static_assert(std::Constructible<size_t, decltype(impl(priority_tag<2>{}, s_alph_t{}))>,
            "The return type of your alphabet_size implementation must be convertible to size_t.");
        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{});
    }
};

// required to prevent https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89953
template <typename alph_t>
    requires requires { { alphabet_size_fn<alph_t>{} }; }
inline constexpr auto alphabet_size_obj = alphabet_size_fn<alph_t>{};

} // namespace seqan3::detail::adl::only

namespace seqan3
{

template <typename alph_t>
    requires requires { { detail::adl::only::alphabet_size_fn<alph_t>{} }; } &&
             requires { { detail::adl::only::alphabet_size_obj<alph_t>() }; }
inline constexpr auto alphabet_size = detail::adl::only::alphabet_size_obj<alph_t>();

// ============================================================================
// Semialphabet
// ============================================================================

template <typename t>
SEQAN3_CONCEPT Semialphabet =
    std::StrictTotallyOrdered<t> &&
    std::CopyConstructible<t> &&
    std::is_nothrow_copy_constructible_v<t> &&
    requires (t v)
{
    requires seqan3::alphabet_size<t> >= 0;

    { seqan3::to_rank(v) };
};

// ============================================================================
// WritableSemialphabet
// ============================================================================

template <typename t>
SEQAN3_CONCEPT WritableSemialphabet = 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) };
};

// ============================================================================
// WritableAlphabet
// ============================================================================

template <typename t>
SEQAN3_CONCEPT WritableAlphabet = Alphabet<t> && WritableSemialphabet<t> && requires (t v, alphabet_char_t<t> c)
{
    { seqan3::assign_char_to(c, v) };

    { seqan3::char_is_valid_for<t>(c) };
};

// ============================================================================
//  serialisation
// ============================================================================

template <CerealOutputArchive 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 <CerealInputArchive 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
{
// ============================================================================
// ConstexprSemialphabet
// ============================================================================

template <typename t>
SEQAN3_CONCEPT ConstexprSemialphabet = 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>{}));
};

// ============================================================================
// WritableConstexprSemialphabet
// ============================================================================

template <typename t>
SEQAN3_CONCEPT WritableConstexprSemialphabet = ConstexprSemialphabet<t> && WritableSemialphabet<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>{}));
};

// ============================================================================
// ConstexprAlphabet
// ============================================================================

template <typename t>
SEQAN3_CONCEPT ConstexprAlphabet = ConstexprSemialphabet<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>{}));
};

// ============================================================================
// WritableConstexprAlphabet
// ============================================================================

template <typename t>
SEQAN3_CONCEPT WritableConstexprAlphabet =
    ConstexprAlphabet<t> && WritableConstexprSemialphabet<t> && WritableAlphabet<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>{}));
    requires SEQAN3_IS_CONSTEXPR(seqan3::char_is_valid_for<t>(alphabet_char_t<t>{}));
};

} // namespace seqan3::detail

#include <seqan3/alphabet/detail/hash.hpp>